Struct LibSqlConnection 

pub struct LibSqlConnection { /* private fields */ }

A Diesel connection backed by libsql.

Supports local SQLite databases (:memory: and file-based) as well as remote Turso databases and embedded replicas.

Implementations

impl LibSqlConnection

pub fn establish_replica( local_path: &str, remote_url: &str, auth_token: &str, ) -> ConnectionResult<Self>

Establish an embedded replica connection.

The replica maintains a local SQLite file at local_path that syncs from remote_url using the provided auth_token. Reads are served locally; writes are delegated to the remote primary.

Call sync to pull the latest state from the remote.

pub fn sync(&mut self) -> QueryResult<()>

Sync the embedded replica with the remote primary.

Returns Ok(()) on success. If this connection is not a replica (i.e., it is a local or pure-remote connection), this is a no-op.

pub fn alter_column( &mut self, table: &str, column: &str, new_definition: &str, ) -> QueryResult<()>

Execute a libSQL-specific ALTER TABLE ... ALTER COLUMN ... TO ... statement.

The new_definition should include the column name, type, and any constraints. For example:

conn.alter_column("users", "name", "name TEXT NOT NULL DEFAULT 'unknown'")?;

This generates: ALTER TABLE users ALTER COLUMN name TO name TEXT NOT NULL DEFAULT 'unknown'

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

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

Run a transaction with BEGIN IMMEDIATE.

Acquires a reserved lock immediately, preventing other writers. Useful when you know you will write and want to avoid SQLITE_BUSY.

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

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

Run a transaction with BEGIN EXCLUSIVE.

Acquires an exclusive lock immediately, preventing all other connections from reading or writing.

pub fn last_insert_rowid(&self) -> i64

Returns the row ID of the last successful INSERT.

Returns 0 if no INSERT has been performed on this connection.

pub fn replica_builder( local_path: impl Into<String>, remote_url: impl Into<String>, auth_token: impl Into<String>, ) -> ReplicaBuilder

Create a ReplicaBuilder for configuring an embedded replica connection.

Trait Implementations

impl Connection for LibSqlConnection

type Backend = LibSql

The backend this type connects to

type TransactionManager = AnsiTransactionManager

The transaction manager implementation used by this connection

fn establish(database_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 AnsiTransactionManager

where Self: Sized,

Get access to the current transaction state of this connection

fn instrumentation(&mut self) -> &mut dyn Instrumentation

Get the instrumentation instance stored in this connection

fn set_instrumentation(&mut self, instrumentation: impl Instrumentation)

Set a specific Instrumentation implementation for this connection

fn set_prepared_statement_cache_size(&mut self, _size: CacheSize)

Set the prepared statement cache size to CacheSize for 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 LoadConnection for LibSqlConnection

type Cursor<'conn, 'query> = LibSqlCursor

The cursor type returned by LoadConnection::load

type Row<'conn, 'query> = LibSqlRow

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 MigrationConnection for LibSqlConnection

fn setup(&mut self) -> QueryResult<usize>

Setup the following table:

impl MultiConnectionHelper for LibSqlConnection

fn to_any<'a>( lookup: &mut <Self::Backend as TypeMetadata>::MetadataLookup, ) -> &mut (dyn Any + 'a)

Convert the lookup type to any

fn from_any( lookup: &mut dyn Any, ) -> Option<&mut <Self::Backend as TypeMetadata>::MetadataLookup>

Get the lookup type from any

impl SimpleConnection for LibSqlConnection

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

Execute multiple SQL statements within the same string.

impl WithMetadataLookup for LibSqlConnection

fn metadata_lookup(&mut self) -> &mut <LibSql as TypeMetadata>::MetadataLookup

Retrieves the underlying metadata lookup

impl ConnectionSealed for LibSqlConnection

impl Send for LibSqlConnection