spaceship_db - v0.1.0

spaceship_db

Types

AsyncDb

</>

Database handle for asynchronous drivers.

pub type AsyncDb {
  AsyncDb(
    driver: driver.AsyncDriver,
    connection: driver.Connection,
  )
}

Constructors

AsyncPrepared

</>

Prepared statement for an asynchronous driver.

pub type AsyncPrepared {
  AsyncPrepared(db: AsyncDb, statement: driver.Statement)
}

Constructors

AsyncTransaction

</>

Async transaction context.

Carries driver-specific state. Turso uses this to track the baton across requests. SQLite and D1 return the same transaction for every operation.

pub type AsyncTransaction {
  AsyncTransaction(
    state: dynamic.Dynamic,
    exec_fn: fn(dynamic.Dynamic, String, List(value.Value)) -> promise.Promise(
      Result(#(List(dynamic.Dynamic), dynamic.Dynamic), String),
    ),
    commit_fn: fn(dynamic.Dynamic) -> promise.Promise(
      Result(Nil, String),
    ),
    rollback_fn: fn(dynamic.Dynamic) -> promise.Promise(
      Result(Nil, String),
    ),
  )
}

Constructors

Db

</>

Database handle.

pub type Db {
  Db(driver: driver.Driver, connection: driver.Connection)
}

Constructors

Prepared

</>

Prepared statement bound to its database.

pub type Prepared {
  Prepared(db: Db, statement: driver.Statement)
}

Constructors

Values

async_transaction

</> 
pub fn async_transaction(
  db: AsyncDb,
  f: fn(AsyncTransaction) -> promise.Promise(Result(a, String)),
) -> promise.Promise(Result(a, String))

Start an async transaction, run the callback, and commit or roll back.

close

</> 
pub fn close(db: Db) -> Result(Nil, String)

Close the database connection.

commit_async_tx

</> 
pub fn commit_async_tx(
  tx: AsyncTransaction,
) -> promise.Promise(Result(Nil, String))

Commit an async transaction explicitly.

decode_all

</> 
pub fn decode_all(
  rows: List(dynamic.Dynamic),
  decoder: decode.Decoder(t),
) -> Result(List(t), String)

Decode all rows using a Decoder.

let user_decoder = {
  use id <- decode.field(0, decode.int)
  use name <- decode.field(1, decode.string)
  decode.success(#(id, name))
}
let assert Ok(users) = spaceship_db.decode_all(rows, user_decoder)

decode_one

</> 
pub fn decode_one(
  rows: List(dynamic.Dynamic),
  decoder: decode.Decoder(t),
) -> Result(t, String)

Decode first row using a Decoder.

exec

</> 
pub fn exec(
  prepared: Prepared,
  params: List(value.Value),
  f: fn(List(dynamic.Dynamic)) -> Result(a, String),
) -> Result(a, String)

Execute a prepared statement with parameters. Use with:

use rows <- spaceship_db.exec(prepared, [])

Returns List(Dynamic) where each element is one row.

exec_async

</> 
pub fn exec_async(
  prepared: AsyncPrepared,
  params: List(value.Value),
  f: fn(List(dynamic.Dynamic)) -> promise.Promise(
    Result(a, String),
  ),
) -> promise.Promise(Result(a, String))

Execute a statement for an asynchronous driver.

exec_async_tx

</> 
pub fn exec_async_tx(
  tx: AsyncTransaction,
  sql: String,
  params: List(value.Value),
  f: fn(#(List(dynamic.Dynamic), AsyncTransaction)) -> promise.Promise(
    Result(a, String),
  ),
) -> promise.Promise(Result(a, String))

Execute a SQL statement within an async transaction.

get_all

</> 
pub fn get_all(
  rows: List(dynamic.Dynamic),
) -> List(dynamic.Dynamic)

Get all rows from query results.

get_one

</> 
pub fn get_one(
  rows: List(dynamic.Dynamic),
) -> option.Option(dynamic.Dynamic)

Get first row from query results. None if empty.

prepare

</> 
pub fn prepare(
  db: Db,
  sql: String,
  f: fn(Prepared) -> Result(a, String),
) -> Result(a, String)

Prepare a SQL statement. Use with:

use prepared <- spaceship_db.prepare(db, "SELECT * FROM users")

prepare_async

</> 
pub fn prepare_async(
  db: AsyncDb,
  sql: String,
  f: fn(AsyncPrepared) -> promise.Promise(Result(a, String)),
) -> promise.Promise(Result(a, String))

Prepare a statement for an asynchronous driver.

rollback_async_tx

</> 
pub fn rollback_async_tx(
  tx: AsyncTransaction,
) -> promise.Promise(Result(Nil, String))

Roll back an async transaction explicitly.

transaction

</> 
pub fn transaction(
  db: Db,
  f: fn(driver.Transaction) -> Result(a, String),
) -> Result(a, String)

Execute a function within a transaction.

with_async_db

</> 
pub fn with_async_db(
  driver: driver.AsyncDriver,
  f: fn(AsyncDb) -> promise.Promise(Result(a, String)),
) -> promise.Promise(Result(a, String))

Use an asynchronous database connection and close it after the callback completes.

with_db

</> 
pub fn with_db(
  driver: driver.Driver,
  f: fn(Db) -> Result(a, String),
) -> Result(a, String)

Use a database connection with automatic cleanup. The connection is closed when the callback returns. Use with:

fn list_users() {
  use db <- with_db(sqlite(path: "./app.db"))
  use prepared <- prepare(db, "SELECT * FROM users")
  exec(prepared, [])
}
✨ Search Document