Struct PreparedStatement 

pub struct PreparedStatement<'a> {
    pub inner: PreparedStatement<'a, SQLiteValue<'a>>,
}

SQLite-specific prepared statement wrapper.

A prepared statement represents a compiled SQL query with placeholder parameters that can be executed multiple times with different parameter values. This wrapper provides SQLite-specific functionality while maintaining compatibility with the core Drizzle prepared statement infrastructure.

Features

• Parameter Binding: Safely bind values to SQL placeholders
• Reusable Execution: Execute the same query multiple times efficiently
• Memory Management: Automatic handling of borrowed/owned lifetimes
• Type Safety: Compile-time verification of parameter types

Basic Usage

use drizzle_sqlite::builder::QueryBuilder;
use drizzle_macros::{SQLiteTable, SQLiteSchema};
use drizzle_core::{ToSQL, expressions::eq};

#[SQLiteTable(name = "users")]
struct User {
    #[integer(primary)]
    id: i32,
    #[text]
    name: String,
}

#[derive(SQLiteSchema)]
struct Schema {
    user: User,
}

let builder = QueryBuilder::new::<Schema>();
let Schema { user } = Schema::new();

// Build query that will become a prepared statement
let query = builder
    .select(user.name)
    .from(user)
    .r#where(eq(user.id, drizzle_core::Placeholder::question()));

// Convert to prepared statement (this would typically be done by the driver)
let sql = query.to_sql();
println!("SQL: {}", sql.sql());  // "SELECT "users"."name" FROM "users" WHERE "users"."id" = ?"

Lifetime Management

The prepared statement can be converted between borrowed and owned forms:

• PreparedStatement<'a> - Borrows data with lifetime ’a
• OwnedPreparedStatement - Owns all data, no lifetime constraints

This allows for flexible usage patterns depending on whether you need to store the prepared statement long-term or use it immediately.

Fields

inner: PreparedStatement<'a, SQLiteValue<'a>>

Implementations

impl<'a> PreparedStatement<'a>

pub fn into_owned(&self) -> OwnedPreparedStatement

Converts this borrowed prepared statement into an owned one.

This method clones all the internal data to create an OwnedPreparedStatement that doesn’t have any lifetime constraints. This is useful when you need to store the prepared statement beyond the lifetime of the original query builder.

Examples

// Convert borrowed to owned for long-term storage
let owned = prepared_statement.into_owned();

// Now `owned` can be stored without lifetime constraints

Trait Implementations

impl<'a> Clone for PreparedStatement<'a>

fn clone(&self) -> PreparedStatement<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for PreparedStatement<'a>

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

Formats the value using the given formatter.

impl<'a> Display for PreparedStatement<'a>

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

Formats the value using the given formatter.

impl From<OwnedPreparedStatement> for PreparedStatement<'_>

fn from(value: OwnedPreparedStatement) -> Self

Converts to this type from the input type.

impl<'a> From<PreparedStatement<'a>> for OwnedPreparedStatement

fn from(value: PreparedStatement<'a>) -> Self

Converts to this type from the input type.