[package]
name = "sqlsrv"
version = "0.0.1"
version = "0.0.2"
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"

]

[dependencies]
parking_lot = { version = "0.12.1" }
r2d2 = { version = "0.8.10" }
r2d2_sqlite = { version = "0.23.0" }
rusqlite = { version = "0.30.0", features = ["hooks"] }
swctx = { version = "0.2.1" }
swctx = { version = "0.2.2" }
threadpool = { version = "1.8.1" }

[package.metadata.docs.rs]
rustdoc-args = ["--generate-link-to-definition"]

use rusqlite::{params, Connection, ToSql};

use sqlsrv::SchemaMgr;

struct Schema {}

impl SchemaMgr for Schema {
  fn init(
    &self,
    conn: &mut Connection,
    newdb: bool
  fn init(&self, conn: &Connection, newdb: bool) -> Result<(), sqlsrv::Error> {
  ) -> Result<(), sqlsrv::Error> {
    if newdb {
      conn.execute(
        "CREATE TABLE IF NOT EXISTS snarks (
  id   INTEGER  PRIMARY KEY,
  data TEXT     UNIQUE NOT NULL,
  ts   DATETIME DEFAULT CURRENT_TIMESTAMP,
  CHECK (length(data) == 64)

};

use parking_lot::{Condvar, Mutex};

use r2d2::{CustomizeConnection, PooledConnection};

use r2d2_sqlite::SqliteConnectionManager;

pub use rusqlite;

use rusqlite::{params, Connection, OpenFlags};

use threadpool::ThreadPool;

pub use changehook::ChangeLogHook;
pub use err::Error;

  ///
  /// While this method can be used to perform schema upgrades, there are two
  /// specialized methods (`need_upgrade()` and `upgrade()`) that can be used
  /// for this purpose instead.
  ///
  /// The default implementation does nothing but returns `Ok(())`.
  #[allow(unused_variables)]
  fn init(&self, conn: &Connection, newdb: bool) -> Result<(), Error> {
  fn init(&self, conn: &mut Connection, newdb: bool) -> Result<(), Error> {
    Ok(())
  }

  /// Application callback used to determine if the database schema is out of
  /// date and needs to be updated.
  ///
  /// The default implementation does nothing but returns `Ok(false)`.
  #[allow(unused_variables)]
  fn need_upgrade(&self, conn: &Connection) -> Result<bool, Error> {
    Ok(false)
  }

  /// Upgrade the database schema.
  ///
  /// This is called if [`SchemaMgr::need_upgrade()`] returns `Ok(true)`.
  ///
  /// The default implementation does nothing but returns `Ok(())`.
  #[allow(unused_variables)]
  fn upgrade(&self, conn: &Connection) -> Result<(), Error> {
  fn upgrade(&self, conn: &mut Connection) -> Result<(), Error> {
    Ok(())
  }
}


#[derive(Clone, Debug)]
struct AutoClean {

    //
    // 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 conn = self.open_writer(fname)?;
    let mut conn = self.open_writer(fname)?;

    //
    // 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
    //
    self.schmgr.init(&conn, !db_exists)?;
    self.schmgr.init(&mut conn, !db_exists)?;
    if self.schmgr.need_upgrade(&conn)? {
      self.schmgr.upgrade(&conn)?;
      self.schmgr.upgrade(&mut conn)?;
    }

    //
    // Perform a full vacuum if requested to do so.
    //
    if self.full_vacuum {
      self.full_vacuum(&conn)?;

    //
    // 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 conn = self.open_writer(fname)?;
    let mut conn = self.open_writer(fname)?;

    //
    // 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
    //
    self.schmgr.init(&conn, !db_exists)?;
    self.schmgr.init(&mut conn, !db_exists)?;
    if self.schmgr.need_upgrade(&conn)? {
      self.schmgr.upgrade(&conn)?;
      self.schmgr.upgrade(&mut conn)?;
    }

    //
    // Perform a full vacuum if requested to do so.
    //
    if self.full_vacuum {
      self.full_vacuum(&conn)?;

# Change Log

## [Unreleased]

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

### Added

- Re-export rusqlite.

### Changed

- Pass mutable `Connection` to schema handler's `init()` and `upgrade()`.

### Removed

---

## [0.0.1] - 2024-01-09