Struct quaint::single::Quaint

pub struct Quaint { /* private fields */ }

The main entry point and an abstraction over a database connection.

Implementations

impl Quaint

pub async fn new(url_str: &str) -> Result<Self>

Create a new connection to the database. The connection string follows the specified format:

connector_type://user:password@host/database?parameters

Connector type can be one of the following:

• file opens an SQLite connection
• mysql opens a MySQL connection
• postgres/postgresql opens a PostgreSQL connection

All parameters should be given in the query string format: ?key1=val1&key2=val2. All parameters are optional.

As a special case, Microsoft SQL Server connections use the JDBC URI format:

jdbc:sqlserver://host\instance:port;key1=val1;key2=val2;

SQLite:

• user/password do not do anything and can be emitted.
• host should point to the database file.
• db_name parameter should give a name to the database attached for query namespacing.
• socket_timeout defined in seconds. Acts as the busy timeout in SQLite. When set, queries that are waiting for a lock to be released will return the Timeout error after the defined value.

PostgreSQL:

• sslmode either disable, prefer or require.
• sslcert should point to a PEM certificate file.
• sslidentity should point to a PKCS12 certificate database.
• sslpassword the password to open the PKCS12 database.
• sslaccept either strict or accept_invalid_certs. If strict, the certificate needs to be valid and in the CA certificates. accept_invalid_certs accepts any certificate from the server and can lead to weakened security. Defaults to strict.
• schema the default search path.
• host additionally the host can be given as a parameter, typically in cases when connectiong to the database through a unix socket to separate the database name from the database path, such as postgresql:///dbname?host=/var/run/postgresql.
• socket_timeout defined in seconds. If set, a query will return a Timeout error if it fails to resolve before given time.
• connect_timeout defined in seconds (default: 5). Connecting to a database will return a ConnectTimeout error if taking more than the defined value.
• pgbouncer either true or false. If set, allows usage with the pgBouncer connection pool in transaction mode. Additionally a transaction is required for every query for the mode to work. When starting a new transaction, a deallocation query DEALLOCATE ALL is executed right after BEGIN to avoid possible collisions with statements created in other sessions.
• statement_cache_size, number of prepared statements kept cached. Defaults to 500, which means caching is off. If pgbouncer mode is enabled, caching is always off.
• options Specifies command-line options to send to the server at connection start.

MySQL:

• sslcert should point to a PEM certificate file.
• sslidentity should point to a PKCS12 certificate database.
• sslpassword the password to open the PKCS12 database.
• sslaccept either strict or accept_invalid_certs. If strict, the certificate needs to be valid and in the CA certificates. accept_invalid_certs accepts any certificate from the server and can lead to weakened security. Defaults to strict.
• socket needed when connecting to MySQL database through a unix socket. When set, the host parameter is dismissed.
• socket_timeout defined in seconds. If set, a query will return a Timeout error if it fails to resolve before given time.
• connect_timeout defined in seconds (default: 5). Connecting to a database will return a ConnectTimeout error if taking more than the defined value.

Microsoft SQL Server:

• encrypt if set to true encrypts all traffic over TLS. If false, only the login details are encrypted. A special value DANGER_PLAINTEXT will disable TLS completely, including sending login credentials as plaintext.
• user sets the login name.
• password sets the login password.
• database sets the database to connect to.
• trustServerCertificate if set to true, accepts any kind of certificate from the server.
• socketTimeout defined in seconds. If set, a query will return a Timeout error if it fails to resolve before given time.
• connectTimeout defined in seconds (default: 5). Connecting to a database will return a ConnectTimeout error if taking more than the defined value.
• connectionLimit defines the maximum number of connections opened to the database.
• schema the name of the lookup schema. Only stored to the connection, must be used in every query to be effective.
• isolationLevel the transaction isolation level. Possible values: READ UNCOMMITTED, READ COMMITTED, REPEATABLE READ, SNAPSHOT, SERIALIZABLE.

pub fn new_in_memory() -> Result<Quaint>

Available on sqlite only.

Open a new SQLite database in memory.

pub fn connection_info(&self) -> &ConnectionInfo

Info about the connection and underlying database.

Trait Implementations

impl Clone for Quaint

fn clone(&self) -> Quaint

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Quaint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Queryable for Quaint

fn query<'life0, 'life1, 'async_trait>( &'life0 self, q: Query<'life1> ) -> Pin<Box<dyn Future<Output = Result<ResultSet>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute the given query.

fn query_raw<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, sql: &'life1 str, params: &'life2 [Value<'life3>] ) -> Pin<Box<dyn Future<Output = Result<ResultSet>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute a query given as SQL, interpolating the given parameters.

fn query_raw_typed<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, sql: &'life1 str, params: &'life2 [Value<'life3>] ) -> Pin<Box<dyn Future<Output = Result<ResultSet>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute a query given as SQL, interpolating the given parameters.

fn execute<'life0, 'life1, 'async_trait>( &'life0 self, q: Query<'life1> ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute the given query, returning the number of affected rows.

fn execute_raw<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, sql: &'life1 str, params: &'life2 [Value<'life3>] ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute a query given as SQL, interpolating the given parameters and returning the number of affected rows.

fn execute_raw_typed<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, sql: &'life1 str, params: &'life2 [Value<'life3>] ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Execute a query given as SQL, interpolating the given parameters and returning the number of affected rows.

fn raw_cmd<'life0, 'life1, 'async_trait>( &'life0 self, cmd: &'life1 str ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Run a command in the database, for queries that can’t be run using prepared statements.

fn version<'life0, 'async_trait>( &'life0 self ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Return the version of the underlying database, queried directly from the source. This corresponds to the version() function on PostgreSQL for example. The version string is returned directly without any form of parsing or normalization.

fn is_healthy(&self) -> bool

Returns false, if connection is considered to not be in a working state.

fn begin_statement(&self) -> &'static str

Statement to begin a transaction

fn set_tx_isolation_level<'life0, 'async_trait>( &'life0 self, isolation_level: IsolationLevel ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait,

Sets the transaction isolation level to given value. Implementers have to make sure that the passed isolation level is valid for the underlying database.

fn requires_isolation_first(&self) -> bool

Signals if the isolation level SET needs to happen before or after the tx BEGIN.

fn select<'life0, 'life1, 'async_trait>( &'life0 self, q: Select<'life1> ) -> Pin<Box<dyn Future<Output = Result<ResultSet>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a SELECT query.

fn insert<'life0, 'life1, 'async_trait>( &'life0 self, q: Insert<'life1> ) -> Pin<Box<dyn Future<Output = Result<ResultSet>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute an INSERT query.

fn update<'life0, 'life1, 'async_trait>( &'life0 self, q: Update<'life1> ) -> Pin<Box<dyn Future<Output = Result<u64>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute an UPDATE query, returning the number of affected rows.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, q: Delete<'life1> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute a DELETE query, returning the number of affected rows.

fn server_reset_query<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _: &'life1 Transaction<'life2> ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Execute an arbitrary function in the beginning of each transaction.

impl TransactionCapable for Quaint

fn start_transaction<'life0, 'async_trait>( &'life0 self, isolation: Option<IsolationLevel> ) -> Pin<Box<dyn Future<Output = Result<Transaction<'_>>> + Send + 'async_trait>>where Self: Sync + 'async_trait, 'life0: 'async_trait,

Starts a new transaction