[package]
name = "sqlsrv"
version = "0.1.1"
edition = "2021"
license = "0BSD"
categories = [ "database" ]
keywords = [ "sqlite", "server" ]
repository = "https://repos.qrnch.tech/pub/sqlsrv"
description = "Utility functions for managing SQLite connections in a server application."
rust-version = "1.56"

mod changehook;
mod err;
mod rawhook;
mod wrconn;

use std::{
  fmt, mem::ManuallyDrop, num::NonZeroUsize, path::Path, str::FromStr,
  sync::Arc
};

use parking_lot::{Condvar, Mutex};

use r2d2::{CustomizeConnection, PooledConnection};

use r2d2_sqlite::SqliteConnectionManager;

  /// The number of pages to process from the freelist each time an
  /// incremental autovacuum is triggered.
  ///
  /// If this is `None` then all pages will be processed.
  npages: Option<NonZeroUsize>
}

type RoRegCb = dyn Fn(&Connection) + Send + Sync;
type RwRegCb = dyn Fn(&Connection);

/// Read-only connection.

struct RoConn {
  regfuncs: Option<Arc<RoRegCb>>
}

impl fmt::Debug for RoConn {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    write!(f, "RoConn {{}}")
  }
}


impl CustomizeConnection<rusqlite::Connection, rusqlite::Error> for RoConn {
  fn on_acquire(
    &self,
    conn: &mut rusqlite::Connection
  ) -> Result<(), rusqlite::Error> {
    conn.pragma_update(None, "foreign_keys", "ON")?;

    if let Some(ref regfuncs) = self.regfuncs {
      regfuncs(conn);
    }

    Ok(())
  }

  fn on_release(&self, _conn: rusqlite::Connection) {}
}

pub struct Builder {
  schmgr: Box<dyn SchemaMgr>,
  full_vacuum: bool,
  max_readers: usize,
  #[cfg(feature = "tpool")]
  thrdpool: ThrdPool,
  autoclean: Option<AutoClean>,
  hook: Option<Arc<dyn Hook + Send + Sync>>,
  rofuncs: Option<Box<RoRegCb>>,
  rwfuncs: Option<Box<RwRegCb>>
}

/// Internal methods.
impl Builder {
  /// Open the writer connection.
  fn open_writer(&self, fname: &Path) -> Result<Connection, rusqlite::Error> {
    let conn = Connection::open(fname)?;

  fn full_vacuum(&self, conn: &Connection) -> Result<(), rusqlite::Error> {
    conn.execute("VACUUM;", params![])?;
    Ok(())
  }

  fn create_ro_pool(
    &self,
    fname: &Path,
    regfuncs: Option<Box<RoRegCb>>
  ) -> Result<r2d2::Pool<SqliteConnectionManager>, r2d2::Error> {
    let fl =
      OpenFlags::SQLITE_OPEN_READ_ONLY | OpenFlags::SQLITE_OPEN_NO_MUTEX;
    let manager = SqliteConnectionManager::file(fname).with_flags(fl);
    let regfuncs = regfuncs.map(Arc::from);
    let roconn_initterm = RoConn { regfuncs };
    let max_readers = u32::try_from(self.max_readers).unwrap();
    r2d2::Pool::builder()
      .max_size(max_readers)
      .connection_customizer(Box::new(roconn_initterm))
      .build(manager)
  }

    Self {
      schmgr,
      full_vacuum: false,
      max_readers: 2,
      #[cfg(feature = "tpool")]
      thrdpool: ThrdPool::default(),
      autoclean: None,
      hook: None,
      rofuncs: None,
      rwfuncs: None
    }
  }

  /// Trigger a full vacuum when initializing the connection pool.
  ///
  /// Operates on an owned `Builder` object.
  pub fn init_vacuum(mut self) -> Self {

  ) -> Self {
    self.autoclean = Some(AutoClean {
      dirt_threshold: dirt_watermark,
      npages
    });
    self
  }

  pub fn register_ro_functions<F>(mut self, f: F) -> Self
  where
    F: Fn(&Connection) + Send + Sync + 'static
  {
    self.rofuncs = Some(Box::new(f));
    self
  }

  pub fn register_rw_functions<F>(mut self, f: F) -> Self
  where
    F: Fn(&Connection) + 'static
  {
    self.rwfuncs = Some(Box::new(f));
    self
  }

  /// Construct a connection pool.
  pub fn build<P>(mut self, fname: P) -> Result<ConnPool, Error>
  where
    P: AsRef<Path>
  {
    // ToDo: Use std::path::absolute() once stabilized
    let fname = fname.as_ref();
    let db_exists = fname.exists();

    //
    // Set up the read/write connection
    //
    // This must be done before creating the read-only connection pool, because
    // at that point the database file must already exist.
    //
    let mut conn = self.open_writer(fname)?;

    // Register read/write connection functions
    if let Some(ref regfn) = self.rwfuncs {
      regfn(&conn);
    }

    //
    // Perform schema initialization.
    //
    // This must be done after auto_vacuum is set, because auto_vacuum requires
    // configuration before any tables have been created.
    // See: https://www.sqlite.org/pragma.html#pragma_auto_vacuum

    //
    #[cfg(feature = "tpool")]
    let tpool = self.init_tpool();

    //
    // Set up connection pool for read-only connections.
    //
    let rofuncs = self.rofuncs.take();
    let rpool = self.create_ro_pool(fname, rofuncs)?;

    //
    // Prepare shared data
    //
    let iconn = InnerWrConn { conn, dirt: 0 };
    let inner = Inner { conn: Some(iconn) };
    let sh = Arc::new(Shared {

  ///
  /// This method should not be called if the application has requested to add
  /// a raw update hook.
  ///
  /// # Panic
  /// This method will panic if a hook has been added to the Builder.
  pub fn build_with_changelog_hook<P, D, T>(
    mut self,
    fname: P,
    hook: Box<dyn ChangeLogHook<Database = D, Table = T> + Send>
  ) -> Result<ConnPool, Error>
  where
    P: AsRef<Path>,
    D: FromStr + Send + Sized + 'static,
    T: FromStr + Send + Sized + 'static

    //
    // Set up the read/write connection
    //
    // This must be done before creating the read-only connection pool, because
    // at that point the database file must already exist.
    //
    let mut conn = self.open_writer(fname)?;

    // Register read/write connection functions
    if let Some(ref regfn) = self.rwfuncs {
      regfn(&conn);
    }

    //
    // Perform schema initialization.
    //
    // This must be done after auto_vacuum is set, because auto_vacuum requires
    // configuration before any tables have been created.
    // See: https://www.sqlite.org/pragma.html#pragma_auto_vacuum

    //
    #[cfg(feature = "tpool")]
    let tpool = self.init_tpool();

    //
    // Set up connection pool for read-only connections.
    //
    let rofuncs = self.rofuncs.take();
    let rpool = self.create_ro_pool(fname, rofuncs)?;

    //
    // Prepare shared data
    //
    let iconn = InnerWrConn { conn, dirt: 0 };
    let inner = Inner { conn: Some(iconn) };
    let sh = Arc::new(Shared {

# Change Log

## [Unreleased]

[Details](/vdiff?from=sqlsrv-0.1.1&to=trunk)

### Added

### Changed

### Removed

---

## [0.1.1] - 2024-01-24

[Details](/vdiff?from=sqlsrv-0.1.0&to=sqlsrv-0.1.1)

### Added

- Add ability to register callback functions for registering SQL functions for
  both read-only and read/write connections.

---

## [0.1.0] - 2024-01-21

[Details](/vdiff?from=sqlsrv-0.0.4&to=sqlsrv-0.1.0)

### Changed