Function select

pub fn select<T: SqlQuery<T> + SqlParams, F, R>(
    conn: &Connection,
    entity: &T,
    to_model: F,
) -> Result<R, Error>
where
    F: Fn(&Row<'_>) -> Result<R, Error>,

select

Executes a custom SELECT query and maps the result to a model using a provided mapping function.

Parameters

• conn: SQLite database connection
• entity: Query parameter object (must implement SqlQuery and SqlParams traits)
• to_model: Function to map a database row to your model type

Return Value

• Result<T, Error>: On success, returns the mapped model; on failure, returns Error

Example Usage

use rusqlite::{Connection, Result, Row};
use parsql_macros::{Queryable, SqlParams};
use parsql_sqlite::select;

fn main() -> Result<()> {
    // Create database connection
    let conn = Connection::open("test.db")?;
    conn.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)", [])?;
    conn.execute("INSERT INTO users (id, name, email) VALUES (1, 'John', 'john@example.com')", [])?;

    // Define your model
    #[derive(Debug)]
    pub struct User {
        pub id: i64,
        pub name: String,
        pub email: String,
    }

    // Define a query
    #[derive(Queryable, SqlParams)]
    #[table("users")]
    #[where_clause("id = ?")]
    pub struct GetUser {
        pub id: i64,
    }

    // Create query parameters
    let get_query = GetUser { id: 1 };

    // Define row mapping function
    let to_user = |row: &Row| -> Result<User> {
        Ok(User {
            id: row.get(0)?,
            name: row.get(1)?,
            email: row.get(2)?,
        })
    };

    // Execute query with custom mapping
    let user = select(&conn, &get_query, to_user)?;
    println!("User: {:?}", user);
    Ok(())
}