Struct Session 

pub struct Session {
    pub database: String,
    pub user: String,
    /* private fields */
}

Session state for a database connection

Fields

database: String

Database name

user: String

User name

Implementations

impl Session

pub fn new(database: String, user: String, db: SharedDatabase) -> Self

Create a new session with a shared database

This constructor is used for wire protocol connections where multiple connections to the same database should share data.

pub fn new_standalone(database: String, user: String) -> Self

Create a new standalone session with its own isolated database

This constructor is used for HTTP API requests and other stateless operations where data isolation between requests is acceptable.

pub fn in_transaction(&self) -> bool

Check if this session is currently in a transaction

pub fn shared_database(&self) -> &SharedDatabase

Get the shared database handle

pub fn with_cache( database: String, user: String, db: SharedDatabase, cache: Arc<PreparedStatementCache>, ) -> Self

Create a new session with a shared statement cache

pub fn prepare(&self, sql: &str) -> Result<Arc<PreparedStatement>>

Prepare a SQL statement for repeated execution

The statement is parsed once and cached. Subsequent calls with the same SQL will return the cached prepared statement without re-parsing.

Example

let stmt = session.prepare("SELECT * FROM users WHERE id = ?")?;
let result = session.execute_prepared(&stmt, &[SqlValue::Integer(1)]).await?;

pub async fn execute_prepared( &mut self, stmt: &PreparedStatement, params: &[SqlValue], ) -> Result<ExecutionResult>

Execute a prepared statement with parameters

Binds the provided parameters to the prepared statement and executes it. This avoids the parsing overhead of the original SQL.

pub async fn execute(&mut self, sql: &str) -> Result<ExecutionResult>

Execute a SQL query with auto-caching

This method automatically caches parsed statements for performance. For repeated queries, use prepare() + execute_prepared() for best performance.

pub async fn execute_with_params( &mut self, sql: &str, params: &[SqlValue], ) -> Result<ExecutionResult>

Execute a SQL query with parameters (convenience method)

Combines prepare + execute_prepared in one call.

pub fn cache_stats(&self) -> PreparedStatementCacheStats

Get prepared statement cache statistics

pub fn clear_cache(&self)

Clear the prepared statement cache

pub async fn begin_transaction(&mut self) -> Result<ExecutionResult>

Begin a transaction

Starts a new transaction for this session. While in a transaction:

• Changes are tracked for potential rollback
• The storage layer manages transaction state

pub async fn commit(&mut self) -> Result<ExecutionResult>

Commit the current transaction

Commits all changes made during this transaction. After commit, changes are permanent and visible to all sessions.

pub async fn rollback(&mut self) -> Result<ExecutionResult>

Rollback the current transaction

Discards all changes made during this transaction. The database state is restored to what it was before BEGIN.