Cargo.toml
README.md
www/index.md
www/changelog.md
src/lib.rs
src/hashing.rs
src/text.rs
src/transcode.rs

[package]
name = "sqlfuncs"
version = "0.1.1"
edition = "2021"
license = "0BSD"
# https://crates.io/category_slugs
categories = [ "database" ]
keywords = [ "sqlite", "rusqlite", "functions" ]
repository = "https://repos.qrnch.tech/pub/sqlfuncs"
description = "Scalar functions for use in SQLite through rusqlite."

# https://doc.rust-lang.org/cargo/reference/manifest.html#the-badges-section
[badges]
maintenance = { status = "actively-developed" }

[dependencies]
digest = { version = "0.10.7" }
hex = { version = "0.4.3" }
orphanage = { version = "0.1.4" }
rusqlite = { version = "0.34.0", features = ["functions"] }
sha2 = { version = "0.10.8" }
sha3 = { version = "0.10.8" }

//! A collection of hashing functions.
//!
//! Hashing functions that take in an algorigm name accept the following names:
//! `sha2/224`, `sha2/256`, `sha2/384`, `sha2/512`, `sha3/224`, `sha3/256`,
//! `sha3/384`, `sha3/512`

use digest::Digest;

use rusqlite::{Connection, Error, functions::FunctionFlags};


fn mkhasher(algo: &str) -> Result<Box<dyn digest::DynDigest>, Error> {
  match algo {
    "sha2/224" => Ok(Box::new(sha2::Sha224::new())),
    "sha2/256" => Ok(Box::new(sha2::Sha256::new())),
    "sha2/384" => Ok(Box::new(sha2::Sha384::new())),

///   [instr],
///   |row| {
///     row.get(0)
///   }
///   ).unwrap();
/// assert_eq!(&hstr[..8], "09ca7e4e");
/// ```
///
/// ## SQLite function properties
/// - Deterministic
/// - Innocuous
/// - UTF8
#[allow(clippy::missing_errors_doc)]
pub fn hashstr(conn: &Connection) -> Result<(), Error> {
  conn.create_scalar_function(
    "hashstr",
    2,
    FunctionFlags::SQLITE_UTF8
      | FunctionFlags::SQLITE_INNOCUOUS

///   [&buf],
///   |row| {
///     row.get(0)
///   }
///   ).unwrap();
/// assert_eq!(&hstr[..8], "09ca7e4e");
/// ```
///
/// ## SQLite function properties
/// - Deterministic
/// - Innocuous
/// - UTF8
#[allow(clippy::missing_errors_doc)]
pub fn hashblob(conn: &Connection) -> Result<(), Error> {
  conn.create_scalar_function(
    "hashblob",
    2,
    FunctionFlags::SQLITE_UTF8
      | FunctionFlags::SQLITE_INNOCUOUS

//! Collection of scalar functions for use with SQLite through rusqlite.

pub mod hashing;
pub mod text;
pub mod transcode;

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

//! A collection of functions intended to work with text strings.

use rusqlite::{Connection, Error, functions::FunctionFlags};

use orphanage::strx::{RndStr, validate_objname};


/// Add a `randomstr()` SQL function to the connection object.
///
/// The SQL function `randomstr()` takes a single argument:
/// 1. The length of the random string, in characters.
///

/// conn.execute(r#"
/// CREATE TABLE IF NOT EXISTS stuff (
///   id   INTEGER PRIMARY KEY,
///   salt TEXT NOT NULL DEFAULT (randomstr(8))
/// );
/// "#, []);
/// ```
///
/// ## SQLite function properties
/// - Innocuous
/// - UTF8
#[allow(clippy::missing_errors_doc)]
pub fn rndstr_alphanum(db: &Connection) -> Result<(), Error> {
  db.create_scalar_function(
    "randomstr",
    1,
    FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_INNOCUOUS,
    move |ctx| {

/// conn.execute(r#"
/// CREATE TABLE IF NOT EXISTS stuff (
///   id   INTEGER PRIMARY KEY,
///   salt TEXT NOT NULL DEFAULT (randomstr(8, "abcdefABCD123456"))
/// );
/// "#, []);
/// ```
///
/// ## SQLite function properties
/// - Innocuous
/// - UTF8
#[allow(clippy::missing_errors_doc)]
pub fn rndstr(db: &Connection) -> Result<(), Error> {
  db.create_scalar_function(
    "randomstr",
    2,
    FunctionFlags::SQLITE_UTF8 | FunctionFlags::SQLITE_INNOCUOUS,
    move |ctx| {

/// CREATE TABLE IF NOT EXISTS stuff (
///   id   INTEGER PRIMARY KEY,
///   name TEXT UNIQUE NOT NULL,
///   CHECK (isobjname(name) == 1)
/// );
/// "#, []);
/// ```
///
/// ## SQLite function properties
/// - Deterministic
/// - Innocuous
/// - UTF8
///
/// # Panics
/// The number of input parameters must be exactly 1.
#[allow(clippy::missing_errors_doc)]
pub fn isobjname(conn: &Connection) -> Result<(), Error> {
  conn.create_scalar_function(
    "isobjname",

//! Functions for transcoding data.

use rusqlite::{Connection, Error, functions::FunctionFlags};

/// Decode a hex encoded string
///
/// The SQL function `dehex()` takes a single argument:
/// 1. The input hex string.
///
/// Its output will be a blob of the decoded data.
///
/// ```
/// use rusqlite::Connection;
/// use sqlfuncs::transcode::dehex;
///
/// let conn = Connection::open_in_memory().unwrap();
/// dehex(&conn).unwrap();
/// let instr = "48656c6c6f20776f726c6421";
/// let buf: Vec<u8> = conn.query_row_and_then(
///   "SELECT dehex(?);", [instr], |row| {
///     row.get(0)
///   }).unwrap();
/// assert_eq!(buf, "Hello world!".to_owned().into_bytes());
/// ```
///
/// ## SQLite function properties
/// - Deterministic
/// - Innocuous
/// - UTF8
#[allow(clippy::missing_errors_doc)]
pub fn dehex(db: &Connection) -> Result<(), Error> {
  db.create_scalar_function(
    "dehex",
    1,
    FunctionFlags::SQLITE_UTF8
      | FunctionFlags::SQLITE_INNOCUOUS
      | FunctionFlags::SQLITE_DETERMINISTIC,
    move |ctx| {
      let hex_input = ctx.get::<String>(0)?;
      let buf = hex::decode(hex_input)
        .map_err(|_| Error::UserFunctionError("Invalid hex".into()))?;
      Ok(buf)
    }
  )
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :

# Change Log

## [Unreleased]

[Details](/vdiff?from=sqlfuncs-0.1.0&to=trunk)

### Added

- Add `transcode` module with `dehex()` sql function.

### Changed

### Removed

---