Enum libsql_client::client::Client

pub enum Client {
    Local(Client),
    Http(Client),
    Hrana(Client),
    Default,
}

A generic client struct, wrapping possible backends. It’s a convenience struct which allows implementing connect() with backends being passed as env parameters.

Variants

Local(Client)

Http(Client)

Hrana(Client)

Default

Implementations

impl Client

pub async fn raw_batch( &self, stmts: impl IntoIterator<Item = impl Into<Statement> + Send> + Send ) -> Result<BatchResult>

Executes a batch of independent SQL statements.

For a version in which statements execute transactionally, see Client::batch()

Arguments

• stmts - SQL statements

Examples

let db = libsql_client::Client::in_memory().unwrap();
let res = db.raw_batch([
  "select * from foo",
  "insert into foo(bar) values ('bar')"
]).await.unwrap();

pub async fn batch<I: IntoIterator<Item = impl Into<Statement> + Send> + Send>( &self, stmts: I ) -> Result<Vec<ResultSet>>

where <I as IntoIterator>::IntoIter: Send,

Transactionally executes a batch of SQL statements.

For a version in which statements can fail or succeed independently, see Client::raw_batch()

Arguments

• stmts - SQL statements

Examples

let db = libsql_client::Client::in_memory().unwrap();
let res = db.batch([
  "select * from foo",
  "insert into foo(bar) values ('bar')"
]).await.unwrap();
assert_eq!(res.len(), 2)

pub fn batch_sync<I: IntoIterator<Item = impl Into<Statement> + Send> + Send>( &self, stmts: I ) -> Result<Vec<ResultSet>>

where <I as IntoIterator>::IntoIter: Send,

Transactionally executes a batch of SQL statements, in synchronous contexts.

This method calls block_on internally.

For the async version of this method, see Client::batch()

Arguments

• stmts - SQL statements

Examples

let db = libsql_client::Client::in_memory().unwrap();
let res = db.batch_sync([
  "select * from foo",
  "insert into foo(bar) values ('bar')"
]).unwrap();
assert_eq!(res.len(), 2)

pub async fn execute( &self, stmt: impl Into<Statement> + Send ) -> Result<ResultSet>

Executes a single SQL statement

Arguments

• stmt - SQL statements

Examples

let db = libsql_client::Client::in_memory().unwrap();
db.execute("select * from foo").await.unwrap();

pub async fn transaction(&self) -> Result<Transaction<'_>>

Creates an interactive transaction

Examples

let db = libsql_client::Client::in_memory().unwrap();
let tx = db.transaction().await.unwrap();
tx.execute("select * from foo").await.unwrap();
tx.commit();

impl Client

pub fn in_memory() -> Result<Client>

Creates an in-memory database

Examples

let db = libsql_client::Client::in_memory().unwrap();

pub async fn from_config<'a>(config: Config) -> Result<Client>

Establishes a database client based on Config struct

Examples

let config = Config {
  url: url::Url::parse("file:////tmp/example.db").unwrap(),
  auth_token: None
};
let db = libsql_client::Client::from_config(config).await.unwrap();

pub async fn from_env() -> Result<Client>

Establishes a database client based on environment variables

Env

• LIBSQL_CLIENT_URL - URL of the database endpoint - e.g. a https:// endpoint for remote connections (with specified credentials) or local file:/// path for a local database
• (optional) LIBSQL_CLIENT_TOKEN - authentication token for the database. Skip if your database does not require authentication

Examples

let db = libsql_client::Client::from_env().await.unwrap();

pub fn from_workers_env(env: &Env) -> Result<Client>

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.

impl Send for Client