Struct ft_sys::SqliteConnection

pub struct SqliteConnection { /* private fields */ }

Implementations

impl SqliteConnection

pub fn connect(url: &str) -> Result<Self, ConnectionError>

Trait Implementations

impl Connection for SqliteConnection

type Backend = Sqlite

The backend this type connects to

type TransactionManager = AnsiTransactionManager

The transaction manager implementation used by this connection

fn establish(url: &str) -> ConnectionResult<Self>

Establishes a new connection to the database

fn execute_returning_count<T>(&mut self, source: &T) -> QueryResult<usize>

where T: QueryFragment<Self::Backend> + QueryId,

Execute a single SQL statements given by a query and return number of affected rows

fn transaction_state( &mut self ) -> &mut <Self::TransactionManager as TransactionManager<Self>>::TransactionStateData

Get access to the current transaction state of this connection

fn transaction<T, E, F>(&mut self, f: F) -> Result<T, E>

where F: FnOnce(&mut Self) -> Result<T, E>, E: From<Error>,

Executes the given function inside of a database transaction

fn begin_test_transaction(&mut self) -> Result<(), Error>

Creates a transaction that will never be committed. This is useful for tests. Panics if called while inside of a transaction or if called with a connection containing a broken transaction

fn test_transaction<T, E, F>(&mut self, f: F) -> T

where F: FnOnce(&mut Self) -> Result<T, E>, E: Debug,

Executes the given function inside a transaction, but does not commit it. Panics if the given function returns an error.

impl<V, T, QId, Op, const STATIC_QUERY_ID: bool> ExecuteDsl<SqliteConnection, Sqlite> for (No, InsertStatement<T, BatchInsert<V, T, QId, STATIC_QUERY_ID>, Op>)

where T: Table + QueryId + 'static, T::FromClause: QueryFragment<Sqlite>, Op: QueryFragment<Sqlite> + QueryId, SqliteBatchInsertWrapper<V, T, QId, STATIC_QUERY_ID>: QueryFragment<Sqlite> + QueryId + CanInsertInSingleQuery<Sqlite>,

fn execute((No, query): Self, conn: &mut SqliteConnection) -> QueryResult<usize>

Execute this command

impl<V, T, QId, Op, const STATIC_QUERY_ID: bool> ExecuteDsl<SqliteConnection, Sqlite> for (Yes, InsertStatement<T, BatchInsert<Vec<ValuesClause<V, T>>, T, QId, STATIC_QUERY_ID>, Op>)

where T: Table + Copy + QueryId + 'static, T::FromClause: QueryFragment<Sqlite>, Op: Copy + QueryId + QueryFragment<Sqlite>, V: InsertValues<T, Sqlite> + CanInsertInSingleQuery<Sqlite> + QueryId,

fn execute( (Yes, query): Self, conn: &mut SqliteConnection ) -> QueryResult<usize>

Execute this command

impl<V, T, QId, Op, O, const STATIC_QUERY_ID: bool> ExecuteDsl<SqliteConnection, Sqlite> for InsertStatement<T, BatchInsert<Vec<ValuesClause<V, T>>, T, QId, STATIC_QUERY_ID>, Op>

where T: QuerySource, V: ContainsDefaultableValue<Out = O>, O: Default, (O, Self): ExecuteDsl<SqliteConnection, Sqlite>,

fn execute(query: Self, conn: &mut SqliteConnection) -> QueryResult<usize>

Execute this command

impl LoadConnection for SqliteConnection

type Cursor<'conn, 'query> = Cursor

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = Row

The row type used as Iterator::Item for the iterator implementation of LoadConnection::Cursor

fn load<'conn, 'query, T>( &'conn mut self, source: T ) -> QueryResult<Self::Cursor<'conn, 'query>>

where T: Query + QueryFragment<Self::Backend> + QueryId + 'query, Self::Backend: QueryMetadata<T::SqlType>,

Executes a given query and returns any requested values

impl SimpleConnection for SqliteConnection

fn batch_execute(&mut self, query: &str) -> QueryResult<()>

Execute multiple SQL statements within the same string.

impl ConnectionSealed for SqliteConnection