pub async fn release_now(mut self) -> Result<C> {
        let (conn, released) = self
            .lock
            .force_release(self.conn.take().expect(NONE_ERR))
            .await?;

        if !released {
            log::warn!(
                "PgAdvisoryLockGuard: advisory lock {:?} was not held by the contained connection",
                self.lock.key
            );
        }

        Ok(conn)
    }
/// Immediately release the held advisory lock instead of when the connection is next used.
///
/// An error should only be returned if there is something wrong with the connection,
/// in which case the lock will be automatically released by the connection closing anyway.
///
/// If `pg_advisory_unlock()` returns `false`, a warning will be logged, both by SQLx as
/// well as the Postgres server. This would only happen if the lock was released without
/// using this guard, or the connection was swapped using [`std::mem::replace()`].
Immediately release the held advisory lock instead of when the connection is next used.
An error should only be returned if there is something wrong with the connection,
in which case the lock will be automatically released by the connection closing anyway.

If `pg_advisory_unlock()` returns `false`, a warning will be logged, both by SQLx as
well as the Postgres server. This would only happen if the lock was released without
using this guard, or the connection was swapped using [`std::mem::replace()`].
Immediately release the held advisory lock instead of when the connection is next used . An error should only be returned if there is something wrong with the connection in which case the lock will be automatically released by the connection closing anyway . If ` pg_advisory_unlock () ` returns ` false ` a warning will be logged both by SQLx as well as the Postgres server . This would only happen if the lock was released without using this guard or the connection was swapped using [ ` std :: mem :: replace () ` ] .
pub async fn release_now(mut self) -> Result<C> {
        let (conn, released) = self
            .lock
            .force_release(self.conn.take().expect(NONE_ERR))
            .await?;
        if !released {
            log::warn!(
                "PgAdvisoryLockGuard: advisory lock {:?} was not held by the contained connection",
                self.lock.key
            );
        }
        Ok(conn)
    }
pub async fn release_now ( mut self ) -> Result < C > { let ( conn , released ) = self . lock . force_release ( self . conn . take ( ) . expect ( NONE_ERR ) ) . await ? ; if ! released { log :: warn ! ( " " self lock key ) ; } Ok ( conn ) }
Immediately release the held advisory lock instead of when the connection is next used.
Immediately release the held advisory lock instead of when the connection is next used .
mut self