mirror of
https://github.com/aljazceru/cdk.git
synced 2025-12-23 15:44:50 +01:00
Introduce cdk-sql-common
The primary purpose of this new crate is to have a common and shared codebase for all SQL storage systems. It would force us to write standard SQL using best practices for all databases. This crate has been extracted from #878
This commit is contained in:
Cesar Rodas
@@ -1,12 +1,13 @@
|
||||
use std::sync::atomic::AtomicBool;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use rusqlite::{params, Connection};
|
||||
|
||||
use crate::pool::{Pool, ResourceManager};
|
||||
use cdk_sql_common::pool::{self, Pool, ResourceManager};
|
||||
use cdk_sql_common::value::Value;
|
||||
use rusqlite::Connection;
|
||||
|
||||
/// The config need to create a new SQLite connection
|
||||
#[derive(Debug)]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct Config {
|
||||
path: Option<String>,
|
||||
password: Option<String>,
|
||||
@@ -25,7 +26,9 @@ impl ResourceManager for SqliteConnectionManager {
|
||||
|
||||
fn new_resource(
|
||||
config: &Self::Config,
|
||||
) -> Result<Self::Resource, crate::pool::Error<Self::Error>> {
|
||||
_still_valid: Arc<AtomicBool>,
|
||||
_timeout: Duration,
|
||||
) -> Result<Self::Resource, pool::Error<Self::Error>> {
|
||||
let conn = if let Some(path) = config.path.as_ref() {
|
||||
Connection::open(path)?
|
||||
} else {
|
||||
@@ -57,14 +60,8 @@ impl ResourceManager for SqliteConnectionManager {
|
||||
/// For SQLCipher support, enable the "sqlcipher" feature and pass a password.
|
||||
pub fn create_sqlite_pool(
|
||||
path: &str,
|
||||
#[cfg(feature = "sqlcipher")] password: String,
|
||||
password: Option<String>,
|
||||
) -> Arc<Pool<SqliteConnectionManager>> {
|
||||
#[cfg(feature = "sqlcipher")]
|
||||
let password = Some(password);
|
||||
|
||||
#[cfg(not(feature = "sqlcipher"))]
|
||||
let password = None;
|
||||
|
||||
let (config, max_size) = if path.contains(":memory:") {
|
||||
(
|
||||
Config {
|
||||
@@ -86,52 +83,26 @@ pub fn create_sqlite_pool(
|
||||
Pool::new(config, max_size, Duration::from_secs(10))
|
||||
}
|
||||
|
||||
/// Migrates the migration generated by `build.rs`
|
||||
pub fn migrate(conn: &mut Connection, migrations: &[(&str, &str)]) -> Result<(), rusqlite::Error> {
|
||||
let tx = conn.transaction()?;
|
||||
tx.execute(
|
||||
r#"
|
||||
CREATE TABLE IF NOT EXISTS migrations (
|
||||
name TEXT PRIMARY KEY,
|
||||
applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
|
||||
)
|
||||
"#,
|
||||
[],
|
||||
)?;
|
||||
|
||||
if tx.query_row(
|
||||
r#"select count(*) from sqlite_master where name = '_sqlx_migrations'"#,
|
||||
[],
|
||||
|row| row.get::<_, i32>(0),
|
||||
)? == 1
|
||||
{
|
||||
tx.execute_batch(
|
||||
r#"
|
||||
INSERT INTO migrations
|
||||
SELECT
|
||||
version || '_' || REPLACE(description, ' ', '_') || '.sql',
|
||||
execution_time
|
||||
FROM _sqlx_migrations;
|
||||
DROP TABLE _sqlx_migrations;
|
||||
"#,
|
||||
)?;
|
||||
/// Convert cdk_sql_common::value::Value to rusqlite Value
|
||||
#[inline(always)]
|
||||
pub fn to_sqlite(v: Value) -> rusqlite::types::Value {
|
||||
match v {
|
||||
Value::Blob(blob) => rusqlite::types::Value::Blob(blob),
|
||||
Value::Integer(i) => rusqlite::types::Value::Integer(i),
|
||||
Value::Null => rusqlite::types::Value::Null,
|
||||
Value::Text(t) => rusqlite::types::Value::Text(t),
|
||||
Value::Real(r) => rusqlite::types::Value::Real(r),
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert from rusqlite Valute to cdk_sql_common::value::Value
|
||||
#[inline(always)]
|
||||
pub fn from_sqlite(v: rusqlite::types::Value) -> Value {
|
||||
match v {
|
||||
rusqlite::types::Value::Blob(blob) => Value::Blob(blob),
|
||||
rusqlite::types::Value::Integer(i) => Value::Integer(i),
|
||||
rusqlite::types::Value::Null => Value::Null,
|
||||
rusqlite::types::Value::Text(t) => Value::Text(t),
|
||||
rusqlite::types::Value::Real(r) => Value::Real(r),
|
||||
}
|
||||
|
||||
// Apply each migration if it hasn’t been applied yet
|
||||
for (name, sql) in migrations {
|
||||
let already_applied: bool = tx.query_row(
|
||||
"SELECT EXISTS(SELECT 1 FROM migrations WHERE name = ?1)",
|
||||
params![name],
|
||||
|row| row.get(0),
|
||||
)?;
|
||||
|
||||
if !already_applied {
|
||||
tx.execute_batch(sql)?;
|
||||
tx.execute("INSERT INTO migrations (name) VALUES (?1)", params![name])?;
|
||||
}
|
||||
}
|
||||
|
||||
tx.commit()?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -4,9 +4,6 @@
|
||||
#![warn(rustdoc::bare_urls)]
|
||||
|
||||
mod common;
|
||||
mod macros;
|
||||
mod pool;
|
||||
mod stmt;
|
||||
|
||||
#[cfg(feature = "mint")]
|
||||
pub mod mint;
|
||||
|
||||
@@ -1,171 +0,0 @@
|
||||
//! Collection of macros to generate code to digest data from SQLite
|
||||
|
||||
/// Unpacks a vector of Column, and consumes it, parsing into individual variables, checking the
|
||||
/// vector is big enough.
|
||||
#[macro_export]
|
||||
macro_rules! unpack_into {
|
||||
(let ($($var:ident),+) = $array:expr) => {
|
||||
let ($($var),+) = {
|
||||
let mut vec = $array.to_vec();
|
||||
vec.reverse();
|
||||
let required = 0 $(+ {let _ = stringify!($var); 1})+;
|
||||
if vec.len() < required {
|
||||
return Err(Error::MissingColumn(required, vec.len()));
|
||||
}
|
||||
Ok::<_, Error>((
|
||||
$(
|
||||
vec.pop().expect(&format!("Checked length already for {}", stringify!($var)))
|
||||
),+
|
||||
))?
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a SQLite column as a string or NULL
|
||||
#[macro_export]
|
||||
macro_rules! column_as_nullable_string {
|
||||
($col:expr, $callback_str:expr, $callback_bytes:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(Some(text).and_then($callback_str)),
|
||||
$crate::stmt::Column::Blob(bytes) => Ok(Some(bytes).and_then($callback_bytes)),
|
||||
$crate::stmt::Column::Null => Ok(None),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
($col:expr, $callback_str:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(Some(text).and_then($callback_str)),
|
||||
$crate::stmt::Column::Blob(bytes) => {
|
||||
Ok(Some(String::from_utf8_lossy(&bytes)).and_then($callback_str))
|
||||
}
|
||||
$crate::stmt::Column::Null => Ok(None),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(Some(text.to_owned())),
|
||||
$crate::stmt::Column::Blob(bytes) => {
|
||||
Ok(Some(String::from_utf8_lossy(&bytes).to_string()))
|
||||
}
|
||||
$crate::stmt::Column::Null => Ok(None),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a column as a number or NULL
|
||||
#[macro_export]
|
||||
macro_rules! column_as_nullable_number {
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(Some(text.parse().map_err(|_| {
|
||||
Error::InvalidConversion(stringify!($col).to_owned(), "Number".to_owned())
|
||||
})?)),
|
||||
$crate::stmt::Column::Integer(n) => Ok(Some(n.try_into().map_err(|_| {
|
||||
Error::InvalidConversion(stringify!($col).to_owned(), "Number".to_owned())
|
||||
})?)),
|
||||
$crate::stmt::Column::Null => Ok(None),
|
||||
other => Err(Error::InvalidType(
|
||||
"Number".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a column as a number
|
||||
#[macro_export]
|
||||
macro_rules! column_as_number {
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => text.parse().map_err(|_| {
|
||||
Error::InvalidConversion(stringify!($col).to_owned(), "Number".to_owned())
|
||||
}),
|
||||
$crate::stmt::Column::Integer(n) => n.try_into().map_err(|_| {
|
||||
Error::InvalidConversion(stringify!($col).to_owned(), "Number".to_owned())
|
||||
}),
|
||||
other => Err(Error::InvalidType(
|
||||
"Number".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a column as a NULL or Binary
|
||||
#[macro_export]
|
||||
macro_rules! column_as_nullable_binary {
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(Some(text.as_bytes().to_vec())),
|
||||
$crate::stmt::Column::Blob(bytes) => Ok(Some(bytes.to_owned())),
|
||||
$crate::stmt::Column::Null => Ok(None),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a SQLite column as a binary
|
||||
#[macro_export]
|
||||
macro_rules! column_as_binary {
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(text.as_bytes().to_vec()),
|
||||
$crate::stmt::Column::Blob(bytes) => Ok(bytes.to_owned()),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
|
||||
/// Parses a SQLite column as a string
|
||||
#[macro_export]
|
||||
macro_rules! column_as_string {
|
||||
($col:expr, $callback_str:expr, $callback_bytes:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => $callback_str(&text).map_err(Error::from),
|
||||
$crate::stmt::Column::Blob(bytes) => $callback_bytes(&bytes).map_err(Error::from),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
($col:expr, $callback:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => $callback(&text).map_err(Error::from),
|
||||
$crate::stmt::Column::Blob(bytes) => {
|
||||
$callback(&String::from_utf8_lossy(&bytes)).map_err(Error::from)
|
||||
}
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
($col:expr) => {
|
||||
(match $col {
|
||||
$crate::stmt::Column::Text(text) => Ok(text.to_owned()),
|
||||
$crate::stmt::Column::Blob(bytes) => Ok(String::from_utf8_lossy(&bytes).to_string()),
|
||||
other => Err(Error::InvalidType(
|
||||
"String".to_owned(),
|
||||
other.data_type().to_string(),
|
||||
)),
|
||||
})?
|
||||
};
|
||||
}
|
||||
@@ -1,16 +1,20 @@
|
||||
//! Async, pipelined rusqlite client
|
||||
use std::marker::PhantomData;
|
||||
use std::path::PathBuf;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::{mpsc as std_mpsc, Arc, Mutex};
|
||||
use std::thread::spawn;
|
||||
use std::time::Instant;
|
||||
|
||||
use cdk_common::database::Error;
|
||||
use cdk_sql_common::database::{DatabaseConnector, DatabaseExecutor, DatabaseTransaction};
|
||||
use cdk_sql_common::pool::{self, Pool, PooledResource};
|
||||
use cdk_sql_common::stmt::{Column, ExpectedSqlResponse, Statement as InnerStatement};
|
||||
use cdk_sql_common::ConversionError;
|
||||
use rusqlite::{ffi, Connection, ErrorCode, TransactionBehavior};
|
||||
use tokio::sync::{mpsc, oneshot};
|
||||
|
||||
use crate::common::SqliteConnectionManager;
|
||||
use crate::mint::Error;
|
||||
use crate::pool::{Pool, PooledResource};
|
||||
use crate::stmt::{Column, ExpectedSqlResponse, Statement as InnerStatement, Value};
|
||||
use crate::common::{create_sqlite_pool, from_sqlite, to_sqlite, SqliteConnectionManager};
|
||||
|
||||
/// The number of queued SQL statements before it start failing
|
||||
const SQL_QUEUE_SIZE: usize = 10_000;
|
||||
@@ -25,9 +29,57 @@ pub struct AsyncRusqlite {
|
||||
inflight_requests: Arc<AtomicUsize>,
|
||||
}
|
||||
|
||||
impl From<PathBuf> for AsyncRusqlite {
|
||||
fn from(value: PathBuf) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(value.to_str().unwrap_or_default(), None))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&str> for AsyncRusqlite {
|
||||
fn from(value: &str) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(value, None))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<(&str, &str)> for AsyncRusqlite {
|
||||
fn from((value, pass): (&str, &str)) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(value, Some(pass.to_owned())))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<(PathBuf, &str)> for AsyncRusqlite {
|
||||
fn from((value, pass): (PathBuf, &str)) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(
|
||||
value.to_str().unwrap_or_default(),
|
||||
Some(pass.to_owned()),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<(&str, String)> for AsyncRusqlite {
|
||||
fn from((value, pass): (&str, String)) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(value, Some(pass)))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<(PathBuf, String)> for AsyncRusqlite {
|
||||
fn from((value, pass): (PathBuf, String)) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(
|
||||
value.to_str().unwrap_or_default(),
|
||||
Some(pass),
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
impl From<&PathBuf> for AsyncRusqlite {
|
||||
fn from(value: &PathBuf) -> Self {
|
||||
AsyncRusqlite::new(create_sqlite_pool(value.to_str().unwrap_or_default(), None))
|
||||
}
|
||||
}
|
||||
|
||||
/// Internal request for the database thread
|
||||
#[derive(Debug)]
|
||||
pub enum DbRequest {
|
||||
enum DbRequest {
|
||||
Sql(InnerStatement, oneshot::Sender<DbResponse>),
|
||||
Begin(oneshot::Sender<DbResponse>),
|
||||
Commit(oneshot::Sender<DbResponse>),
|
||||
@@ -35,97 +87,67 @@ pub enum DbRequest {
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum DbResponse {
|
||||
enum DbResponse {
|
||||
Transaction(mpsc::Sender<DbRequest>),
|
||||
AffectedRows(usize),
|
||||
Pluck(Option<Column>),
|
||||
Row(Option<Vec<Column>>),
|
||||
Rows(Vec<Vec<Column>>),
|
||||
Error(Error),
|
||||
Error(SqliteError),
|
||||
Unexpected,
|
||||
Ok,
|
||||
}
|
||||
|
||||
/// Statement for the async_rusqlite wrapper
|
||||
pub struct Statement(InnerStatement);
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
enum SqliteError {
|
||||
#[error(transparent)]
|
||||
Sqlite(#[from] rusqlite::Error),
|
||||
|
||||
impl Statement {
|
||||
/// Bind a variable
|
||||
pub fn bind<C, V>(self, name: C, value: V) -> Self
|
||||
where
|
||||
C: ToString,
|
||||
V: Into<Value>,
|
||||
{
|
||||
Self(self.0.bind(name, value))
|
||||
}
|
||||
#[error(transparent)]
|
||||
Inner(#[from] Error),
|
||||
|
||||
/// Bind vec
|
||||
pub fn bind_vec<C, V>(self, name: C, value: Vec<V>) -> Self
|
||||
where
|
||||
C: ToString,
|
||||
V: Into<Value>,
|
||||
{
|
||||
Self(self.0.bind_vec(name, value))
|
||||
}
|
||||
#[error(transparent)]
|
||||
Pool(#[from] pool::Error<rusqlite::Error>),
|
||||
|
||||
/// Executes a query and return the number of affected rows
|
||||
pub async fn execute<C>(self, conn: &C) -> Result<usize, Error>
|
||||
where
|
||||
C: DatabaseExecutor + Send + Sync,
|
||||
{
|
||||
conn.execute(self.0).await
|
||||
}
|
||||
/// Duplicate entry
|
||||
#[error("Duplicate")]
|
||||
Duplicate,
|
||||
|
||||
/// Returns the first column of the first row of the query result
|
||||
pub async fn pluck<C>(self, conn: &C) -> Result<Option<Column>, Error>
|
||||
where
|
||||
C: DatabaseExecutor + Send + Sync,
|
||||
{
|
||||
conn.pluck(self.0).await
|
||||
}
|
||||
#[error(transparent)]
|
||||
Conversion(#[from] ConversionError),
|
||||
}
|
||||
|
||||
/// Returns the first row of the query result
|
||||
pub async fn fetch_one<C>(self, conn: &C) -> Result<Option<Vec<Column>>, Error>
|
||||
where
|
||||
C: DatabaseExecutor + Send + Sync,
|
||||
{
|
||||
conn.fetch_one(self.0).await
|
||||
}
|
||||
|
||||
/// Returns all rows of the query result
|
||||
pub async fn fetch_all<C>(self, conn: &C) -> Result<Vec<Vec<Column>>, Error>
|
||||
where
|
||||
C: DatabaseExecutor + Send + Sync,
|
||||
{
|
||||
conn.fetch_all(self.0).await
|
||||
impl From<SqliteError> for Error {
|
||||
fn from(val: SqliteError) -> Self {
|
||||
match val {
|
||||
SqliteError::Duplicate => Error::Duplicate,
|
||||
SqliteError::Conversion(e) => e.into(),
|
||||
o => Error::Internal(o.to_string()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Process a query
|
||||
#[inline(always)]
|
||||
fn process_query(conn: &Connection, sql: InnerStatement) -> Result<DbResponse, Error> {
|
||||
fn process_query(conn: &Connection, statement: InnerStatement) -> Result<DbResponse, SqliteError> {
|
||||
let start = Instant::now();
|
||||
let mut args = sql.args;
|
||||
let mut stmt = conn.prepare_cached(&sql.sql)?;
|
||||
let total_parameters = stmt.parameter_count();
|
||||
let expected_response = statement.expected_response;
|
||||
let (sql, placeholder_values) = statement.to_sql()?;
|
||||
let sql = sql.trim_end_matches("FOR UPDATE");
|
||||
|
||||
for index in 1..=total_parameters {
|
||||
let value = if let Some(value) = stmt.parameter_name(index).map(|name| {
|
||||
args.remove(name)
|
||||
.ok_or(Error::MissingParameter(name.to_owned()))
|
||||
}) {
|
||||
value?
|
||||
} else {
|
||||
continue;
|
||||
};
|
||||
|
||||
stmt.raw_bind_parameter(index, value)?;
|
||||
let mut stmt = conn.prepare_cached(sql)?;
|
||||
for (i, value) in placeholder_values.into_iter().enumerate() {
|
||||
stmt.raw_bind_parameter(i + 1, to_sqlite(value))?;
|
||||
}
|
||||
|
||||
let columns = stmt.column_count();
|
||||
|
||||
let to_return = match sql.expected_response {
|
||||
let to_return = match expected_response {
|
||||
ExpectedSqlResponse::AffectedRows => DbResponse::AffectedRows(stmt.raw_execute()?),
|
||||
ExpectedSqlResponse::Batch => {
|
||||
conn.execute_batch(sql)?;
|
||||
DbResponse::Ok
|
||||
}
|
||||
ExpectedSqlResponse::ManyRows => {
|
||||
let mut rows = stmt.raw_query();
|
||||
let mut results = vec![];
|
||||
@@ -133,7 +155,7 @@ fn process_query(conn: &Connection, sql: InnerStatement) -> Result<DbResponse, E
|
||||
while let Some(row) = rows.next()? {
|
||||
results.push(
|
||||
(0..columns)
|
||||
.map(|i| row.get(i))
|
||||
.map(|i| row.get(i).map(from_sqlite))
|
||||
.collect::<Result<Vec<_>, _>>()?,
|
||||
)
|
||||
}
|
||||
@@ -142,7 +164,11 @@ fn process_query(conn: &Connection, sql: InnerStatement) -> Result<DbResponse, E
|
||||
}
|
||||
ExpectedSqlResponse::Pluck => {
|
||||
let mut rows = stmt.raw_query();
|
||||
DbResponse::Pluck(rows.next()?.map(|row| row.get(0usize)).transpose()?)
|
||||
DbResponse::Pluck(
|
||||
rows.next()?
|
||||
.map(|row| row.get(0usize).map(from_sqlite))
|
||||
.transpose()?,
|
||||
)
|
||||
}
|
||||
ExpectedSqlResponse::SingleRow => {
|
||||
let mut rows = stmt.raw_query();
|
||||
@@ -150,7 +176,7 @@ fn process_query(conn: &Connection, sql: InnerStatement) -> Result<DbResponse, E
|
||||
.next()?
|
||||
.map(|row| {
|
||||
(0..columns)
|
||||
.map(|i| row.get(i))
|
||||
.map(|i| row.get(i).map(from_sqlite))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
})
|
||||
.transpose()?;
|
||||
@@ -161,7 +187,7 @@ fn process_query(conn: &Connection, sql: InnerStatement) -> Result<DbResponse, E
|
||||
let duration = start.elapsed();
|
||||
|
||||
if duration.as_millis() > SLOW_QUERY_THRESHOLD_MS {
|
||||
tracing::warn!("[SLOW QUERY] Took {} ms: {}", duration.as_millis(), sql.sql);
|
||||
tracing::warn!("[SLOW QUERY] Took {} ms: {}", duration.as_millis(), sql);
|
||||
}
|
||||
|
||||
Ok(to_return)
|
||||
@@ -196,13 +222,12 @@ fn rusqlite_spawn_worker_threads(
|
||||
let inflight_requests = inflight_requests.clone();
|
||||
spawn(move || loop {
|
||||
while let Ok((conn, sql, reply_to)) = rx.lock().expect("failed to acquire").recv() {
|
||||
tracing::trace!("Execute query: {}", sql.sql);
|
||||
let result = process_query(&conn, sql);
|
||||
let _ = match result {
|
||||
Ok(ok) => reply_to.send(ok),
|
||||
Err(err) => {
|
||||
tracing::error!("Failed query with error {:?}", err);
|
||||
let err = if let Error::Sqlite(rusqlite::Error::SqliteFailure(
|
||||
let err = if let SqliteError::Sqlite(rusqlite::Error::SqliteFailure(
|
||||
ffi::Error {
|
||||
code,
|
||||
extended_code,
|
||||
@@ -214,7 +239,7 @@ fn rusqlite_spawn_worker_threads(
|
||||
&& (*extended_code == ffi::SQLITE_CONSTRAINT_PRIMARYKEY
|
||||
|| *extended_code == ffi::SQLITE_CONSTRAINT_UNIQUE)
|
||||
{
|
||||
Error::Duplicate
|
||||
SqliteError::Duplicate
|
||||
} else {
|
||||
err
|
||||
}
|
||||
@@ -256,7 +281,7 @@ fn rusqlite_worker_manager(
|
||||
while let Some(request) = receiver.blocking_recv() {
|
||||
inflight_requests.fetch_add(1, Ordering::Relaxed);
|
||||
match request {
|
||||
DbRequest::Sql(sql, reply_to) => {
|
||||
DbRequest::Sql(statement, reply_to) => {
|
||||
let conn = match pool.get() {
|
||||
Ok(conn) => conn,
|
||||
Err(err) => {
|
||||
@@ -267,7 +292,7 @@ fn rusqlite_worker_manager(
|
||||
}
|
||||
};
|
||||
|
||||
let _ = send_sql_to_thread.send((conn, sql, reply_to));
|
||||
let _ = send_sql_to_thread.send((conn, statement, reply_to));
|
||||
continue;
|
||||
}
|
||||
DbRequest::Begin(reply_to) => {
|
||||
@@ -341,9 +366,9 @@ fn rusqlite_worker_manager(
|
||||
DbRequest::Begin(reply_to) => {
|
||||
let _ = reply_to.send(DbResponse::Unexpected);
|
||||
}
|
||||
DbRequest::Sql(sql, reply_to) => {
|
||||
tracing::trace!("Tx {}: SQL {}", tx_id, sql.sql);
|
||||
let _ = match process_query(&tx, sql) {
|
||||
DbRequest::Sql(statement, reply_to) => {
|
||||
tracing::trace!("Tx {}: SQL {:?}", tx_id, statement);
|
||||
let _ = match process_query(&tx, statement) {
|
||||
Ok(ok) => reply_to.send(ok),
|
||||
Err(err) => {
|
||||
tracing::error!(
|
||||
@@ -351,7 +376,7 @@ fn rusqlite_worker_manager(
|
||||
tx_id,
|
||||
err
|
||||
);
|
||||
let err = if let Error::Sqlite(
|
||||
let err = if let SqliteError::Sqlite(
|
||||
rusqlite::Error::SqliteFailure(
|
||||
ffi::Error {
|
||||
code,
|
||||
@@ -365,7 +390,7 @@ fn rusqlite_worker_manager(
|
||||
&& (*extended_code == ffi::SQLITE_CONSTRAINT_PRIMARYKEY
|
||||
|| *extended_code == ffi::SQLITE_CONSTRAINT_UNIQUE)
|
||||
{
|
||||
Error::Duplicate
|
||||
SqliteError::Duplicate
|
||||
} else {
|
||||
err
|
||||
}
|
||||
@@ -395,83 +420,6 @@ fn rusqlite_worker_manager(
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
pub trait DatabaseExecutor {
|
||||
/// Returns the connection to the database thread (or the on-going transaction)
|
||||
fn get_queue_sender(&self) -> mpsc::Sender<DbRequest>;
|
||||
|
||||
/// Executes a query and returns the affected rows
|
||||
async fn execute(&self, mut statement: InnerStatement) -> Result<usize, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::AffectedRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
DbResponse::AffectedRows(n) => Ok(n),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs the query and returns the first row or None
|
||||
async fn fetch_one(&self, mut statement: InnerStatement) -> Result<Option<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::SingleRow;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
DbResponse::Row(row) => Ok(row),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
/// Runs the query and returns the first row or None
|
||||
async fn fetch_all(&self, mut statement: InnerStatement) -> Result<Vec<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::ManyRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
DbResponse::Rows(rows) => Ok(rows),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn pluck(&self, mut statement: InnerStatement) -> Result<Option<Column>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::Pluck;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
DbResponse::Pluck(value) => Ok(value),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn query<T>(sql: T) -> Statement
|
||||
where
|
||||
T: ToString,
|
||||
{
|
||||
Statement(crate::stmt::Statement::new(sql))
|
||||
}
|
||||
|
||||
impl AsyncRusqlite {
|
||||
/// Creates a new Async Rusqlite wrapper.
|
||||
pub fn new(pool: Arc<Pool<SqliteConnectionManager>>) -> Self {
|
||||
@@ -488,45 +436,155 @@ impl AsyncRusqlite {
|
||||
}
|
||||
}
|
||||
|
||||
fn get_queue_sender(&self) -> &mpsc::Sender<DbRequest> {
|
||||
&self.sender
|
||||
}
|
||||
|
||||
/// Show how many inflight requests
|
||||
#[allow(dead_code)]
|
||||
pub fn inflight_requests(&self) -> usize {
|
||||
self.inflight_requests.load(Ordering::Relaxed)
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl DatabaseConnector for AsyncRusqlite {
|
||||
type Transaction<'a> = Transaction<'a>;
|
||||
|
||||
/// Begins a transaction
|
||||
///
|
||||
/// If the transaction is Drop it will trigger a rollback operation
|
||||
pub async fn begin(&self) -> Result<Transaction<'_>, Error> {
|
||||
async fn begin(&self) -> Result<Self::Transaction<'_>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
self.sender
|
||||
.send(DbRequest::Begin(sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Transaction(db_sender) => Ok(Transaction {
|
||||
db_sender,
|
||||
_marker: PhantomData,
|
||||
}),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl DatabaseExecutor for AsyncRusqlite {
|
||||
#[inline(always)]
|
||||
fn get_queue_sender(&self) -> mpsc::Sender<DbRequest> {
|
||||
self.sender.clone()
|
||||
fn name() -> &'static str {
|
||||
"sqlite"
|
||||
}
|
||||
|
||||
async fn fetch_one(&self, mut statement: InnerStatement) -> Result<Option<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::SingleRow;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Row(row) => Ok(row),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn batch(&self, mut statement: InnerStatement) -> Result<(), Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::Batch;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Ok => Ok(()),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn fetch_all(&self, mut statement: InnerStatement) -> Result<Vec<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::ManyRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Rows(row) => Ok(row),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn execute(&self, mut statement: InnerStatement) -> Result<usize, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::AffectedRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::AffectedRows(total) => Ok(total),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn pluck(&self, mut statement: InnerStatement) -> Result<Option<Column>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::Pluck;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Pluck(value) => Ok(value),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Database transaction
|
||||
#[derive(Debug)]
|
||||
pub struct Transaction<'conn> {
|
||||
db_sender: mpsc::Sender<DbRequest>,
|
||||
_marker: PhantomData<&'conn ()>,
|
||||
}
|
||||
|
||||
impl Transaction<'_> {
|
||||
fn get_queue_sender(&self) -> &mpsc::Sender<DbRequest> {
|
||||
&self.db_sender
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for Transaction<'_> {
|
||||
fn drop(&mut self) {
|
||||
let (sender, _) = oneshot::channel();
|
||||
@@ -534,40 +592,136 @@ impl Drop for Transaction<'_> {
|
||||
}
|
||||
}
|
||||
|
||||
impl Transaction<'_> {
|
||||
pub async fn commit(self) -> Result<(), Error> {
|
||||
#[async_trait::async_trait]
|
||||
impl<'a> DatabaseTransaction<'a> for Transaction<'a> {
|
||||
async fn commit(self) -> Result<(), Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
self.db_sender
|
||||
.send(DbRequest::Commit(sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Ok => Ok(()),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn rollback(self) -> Result<(), Error> {
|
||||
async fn rollback(self) -> Result<(), Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
self.db_sender
|
||||
.send(DbRequest::Rollback(sender))
|
||||
.await
|
||||
.map_err(|_| Error::Communication)?;
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver.await.map_err(|_| Error::Communication)? {
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Ok => Ok(()),
|
||||
DbResponse::Error(err) => Err(err),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait::async_trait]
|
||||
impl DatabaseExecutor for Transaction<'_> {
|
||||
/// Get the internal sender to the SQL queue
|
||||
#[inline(always)]
|
||||
fn get_queue_sender(&self) -> mpsc::Sender<DbRequest> {
|
||||
self.db_sender.clone()
|
||||
fn name() -> &'static str {
|
||||
"sqlite"
|
||||
}
|
||||
|
||||
async fn fetch_one(&self, mut statement: InnerStatement) -> Result<Option<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::SingleRow;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Row(row) => Ok(row),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn batch(&self, mut statement: InnerStatement) -> Result<(), Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::Batch;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Ok => Ok(()),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn fetch_all(&self, mut statement: InnerStatement) -> Result<Vec<Vec<Column>>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::ManyRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Rows(row) => Ok(row),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn execute(&self, mut statement: InnerStatement) -> Result<usize, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::AffectedRows;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::AffectedRows(total) => Ok(total),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
|
||||
async fn pluck(&self, mut statement: InnerStatement) -> Result<Option<Column>, Error> {
|
||||
let (sender, receiver) = oneshot::channel();
|
||||
statement.expected_response = ExpectedSqlResponse::Pluck;
|
||||
self.get_queue_sender()
|
||||
.send(DbRequest::Sql(statement, sender))
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?;
|
||||
|
||||
match receiver
|
||||
.await
|
||||
.map_err(|_| Error::Internal("Communication".to_owned()))?
|
||||
{
|
||||
DbResponse::Pluck(value) => Ok(value),
|
||||
DbResponse::Error(err) => Err(err.into()),
|
||||
_ => Err(Error::InvalidDbResponse),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,5 +0,0 @@
|
||||
// @generated
|
||||
// Auto-generated by build.rs
|
||||
pub static MIGRATIONS: &[(&str, &str)] = &[
|
||||
("20250109143347_init.sql", include_str!(r#"./migrations/20250109143347_init.sql"#)),
|
||||
];
|
||||
@@ -1,44 +0,0 @@
|
||||
CREATE TABLE IF NOT EXISTS proof (
|
||||
y BLOB PRIMARY KEY,
|
||||
keyset_id TEXT NOT NULL,
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
state TEXT NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS state_index ON proof(state);
|
||||
CREATE INDEX IF NOT EXISTS secret_index ON proof(secret);
|
||||
|
||||
|
||||
-- Keysets Table
|
||||
|
||||
CREATE TABLE IF NOT EXISTS keyset (
|
||||
id TEXT PRIMARY KEY,
|
||||
unit TEXT NOT NULL,
|
||||
active BOOL NOT NULL,
|
||||
valid_from INTEGER NOT NULL,
|
||||
valid_to INTEGER,
|
||||
derivation_path TEXT NOT NULL,
|
||||
max_order INTEGER NOT NULL,
|
||||
derivation_path_index INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS unit_index ON keyset(unit);
|
||||
CREATE INDEX IF NOT EXISTS active_index ON keyset(active);
|
||||
|
||||
|
||||
CREATE TABLE IF NOT EXISTS blind_signature (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
c BLOB NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS keyset_id_index ON blind_signature(keyset_id);
|
||||
|
||||
|
||||
CREATE TABLE IF NOT EXISTS protected_endpoints (
|
||||
endpoint TEXT PRIMARY KEY,
|
||||
auth TEXT NOT NULL
|
||||
);
|
||||
|
||||
@@ -1,404 +0,0 @@
|
||||
//! SQLite Mint Auth
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::ops::DerefMut;
|
||||
use std::path::Path;
|
||||
use std::str::FromStr;
|
||||
|
||||
use async_trait::async_trait;
|
||||
use cdk_common::database::{self, MintAuthDatabase, MintAuthTransaction};
|
||||
use cdk_common::mint::MintKeySetInfo;
|
||||
use cdk_common::nuts::{AuthProof, BlindSignature, Id, PublicKey, State};
|
||||
use cdk_common::{AuthRequired, ProtectedEndpoint};
|
||||
use tracing::instrument;
|
||||
|
||||
use super::async_rusqlite::AsyncRusqlite;
|
||||
use super::{sqlite_row_to_blind_signature, sqlite_row_to_keyset_info, SqliteTransaction};
|
||||
use crate::column_as_string;
|
||||
use crate::common::{create_sqlite_pool, migrate};
|
||||
use crate::mint::async_rusqlite::query;
|
||||
use crate::mint::Error;
|
||||
|
||||
/// Mint SQLite Database
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct MintSqliteAuthDatabase {
|
||||
pool: AsyncRusqlite,
|
||||
}
|
||||
|
||||
#[rustfmt::skip]
|
||||
mod migrations;
|
||||
|
||||
impl MintSqliteAuthDatabase {
|
||||
/// Create new [`MintSqliteAuthDatabase`]
|
||||
#[cfg(not(feature = "sqlcipher"))]
|
||||
pub async fn new<P: AsRef<Path>>(path: P) -> Result<Self, Error> {
|
||||
let pool = create_sqlite_pool(path.as_ref().to_str().ok_or(Error::InvalidDbPath)?);
|
||||
migrate(pool.get()?.deref_mut(), migrations::MIGRATIONS)?;
|
||||
|
||||
Ok(Self {
|
||||
pool: AsyncRusqlite::new(pool),
|
||||
})
|
||||
}
|
||||
|
||||
/// Create new [`MintSqliteAuthDatabase`]
|
||||
#[cfg(feature = "sqlcipher")]
|
||||
pub async fn new<P: AsRef<Path>>(path: P, password: String) -> Result<Self, Error> {
|
||||
let pool = create_sqlite_pool(
|
||||
path.as_ref().to_str().ok_or(Error::InvalidDbPath)?,
|
||||
password,
|
||||
);
|
||||
migrate(pool.get()?.deref_mut(), migrations::MIGRATIONS)?;
|
||||
|
||||
Ok(Self {
|
||||
pool: AsyncRusqlite::new(pool),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl MintAuthTransaction<database::Error> for SqliteTransaction<'_> {
|
||||
#[instrument(skip(self))]
|
||||
async fn set_active_keyset(&mut self, id: Id) -> Result<(), database::Error> {
|
||||
tracing::info!("Setting auth keyset {id} active");
|
||||
query(
|
||||
r#"
|
||||
UPDATE keyset
|
||||
SET active = CASE
|
||||
WHEN id = :id THEN TRUE
|
||||
ELSE FALSE
|
||||
END;
|
||||
"#,
|
||||
)
|
||||
.bind(":id", id.to_string())
|
||||
.execute(&self.inner)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn add_keyset_info(&mut self, keyset: MintKeySetInfo) -> Result<(), database::Error> {
|
||||
query(
|
||||
r#"
|
||||
INSERT INTO
|
||||
keyset (
|
||||
id, unit, active, valid_from, valid_to, derivation_path,
|
||||
max_order, derivation_path_index
|
||||
)
|
||||
VALUES (
|
||||
:id, :unit, :active, :valid_from, :valid_to, :derivation_path,
|
||||
:max_order, :derivation_path_index
|
||||
)
|
||||
ON CONFLICT(id) DO UPDATE SET
|
||||
unit = excluded.unit,
|
||||
active = excluded.active,
|
||||
valid_from = excluded.valid_from,
|
||||
valid_to = excluded.valid_to,
|
||||
derivation_path = excluded.derivation_path,
|
||||
max_order = excluded.max_order,
|
||||
derivation_path_index = excluded.derivation_path_index
|
||||
"#,
|
||||
)
|
||||
.bind(":id", keyset.id.to_string())
|
||||
.bind(":unit", keyset.unit.to_string())
|
||||
.bind(":active", keyset.active)
|
||||
.bind(":valid_from", keyset.valid_from as i64)
|
||||
.bind(":valid_to", keyset.final_expiry.map(|v| v as i64))
|
||||
.bind(":derivation_path", keyset.derivation_path.to_string())
|
||||
.bind(":max_order", keyset.max_order)
|
||||
.bind(":derivation_path_index", keyset.derivation_path_index)
|
||||
.execute(&self.inner)
|
||||
.await?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn add_proof(&mut self, proof: AuthProof) -> Result<(), database::Error> {
|
||||
if let Err(err) = query(
|
||||
r#"
|
||||
INSERT INTO proof
|
||||
(y, keyset_id, secret, c, state)
|
||||
VALUES
|
||||
(:y, :keyset_id, :secret, :c, :state)
|
||||
"#,
|
||||
)
|
||||
.bind(":y", proof.y()?.to_bytes().to_vec())
|
||||
.bind(":keyset_id", proof.keyset_id.to_string())
|
||||
.bind(":secret", proof.secret.to_string())
|
||||
.bind(":c", proof.c.to_bytes().to_vec())
|
||||
.bind(":state", "UNSPENT".to_string())
|
||||
.execute(&self.inner)
|
||||
.await
|
||||
{
|
||||
tracing::debug!("Attempting to add known proof. Skipping.... {:?}", err);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn update_proof_state(
|
||||
&mut self,
|
||||
y: &PublicKey,
|
||||
proofs_state: State,
|
||||
) -> Result<Option<State>, Self::Err> {
|
||||
let current_state = query(r#"SELECT state FROM proof WHERE y = :y"#)
|
||||
.bind(":y", y.to_bytes().to_vec())
|
||||
.pluck(&self.inner)
|
||||
.await?
|
||||
.map(|state| Ok::<_, Error>(column_as_string!(state, State::from_str)))
|
||||
.transpose()?;
|
||||
|
||||
query(r#"UPDATE proof SET state = :new_state WHERE state = :state AND y = :y"#)
|
||||
.bind(":y", y.to_bytes().to_vec())
|
||||
.bind(
|
||||
":state",
|
||||
current_state.as_ref().map(|state| state.to_string()),
|
||||
)
|
||||
.bind(":new_state", proofs_state.to_string())
|
||||
.execute(&self.inner)
|
||||
.await?;
|
||||
|
||||
Ok(current_state)
|
||||
}
|
||||
|
||||
async fn add_blind_signatures(
|
||||
&mut self,
|
||||
blinded_messages: &[PublicKey],
|
||||
blind_signatures: &[BlindSignature],
|
||||
) -> Result<(), database::Error> {
|
||||
for (message, signature) in blinded_messages.iter().zip(blind_signatures) {
|
||||
query(
|
||||
r#"
|
||||
INSERT
|
||||
INTO blind_signature
|
||||
(y, amount, keyset_id, c)
|
||||
VALUES
|
||||
(:y, :amount, :keyset_id, :c)
|
||||
"#,
|
||||
)
|
||||
.bind(":y", message.to_bytes().to_vec())
|
||||
.bind(":amount", u64::from(signature.amount) as i64)
|
||||
.bind(":keyset_id", signature.keyset_id.to_string())
|
||||
.bind(":c", signature.c.to_bytes().to_vec())
|
||||
.execute(&self.inner)
|
||||
.await?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn add_protected_endpoints(
|
||||
&mut self,
|
||||
protected_endpoints: HashMap<ProtectedEndpoint, AuthRequired>,
|
||||
) -> Result<(), database::Error> {
|
||||
for (endpoint, auth) in protected_endpoints.iter() {
|
||||
if let Err(err) = query(
|
||||
r#"
|
||||
INSERT OR REPLACE INTO protected_endpoints
|
||||
(endpoint, auth)
|
||||
VALUES (:endpoint, :auth);
|
||||
"#,
|
||||
)
|
||||
.bind(":endpoint", serde_json::to_string(endpoint)?)
|
||||
.bind(":auth", serde_json::to_string(auth)?)
|
||||
.execute(&self.inner)
|
||||
.await
|
||||
{
|
||||
tracing::debug!(
|
||||
"Attempting to add protected endpoint. Skipping.... {:?}",
|
||||
err
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
async fn remove_protected_endpoints(
|
||||
&mut self,
|
||||
protected_endpoints: Vec<ProtectedEndpoint>,
|
||||
) -> Result<(), database::Error> {
|
||||
query(r#"DELETE FROM protected_endpoints WHERE endpoint IN (:endpoints)"#)
|
||||
.bind_vec(
|
||||
":endpoints",
|
||||
protected_endpoints
|
||||
.iter()
|
||||
.map(serde_json::to_string)
|
||||
.collect::<Result<_, _>>()?,
|
||||
)
|
||||
.execute(&self.inner)
|
||||
.await?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl MintAuthDatabase for MintSqliteAuthDatabase {
|
||||
type Err = database::Error;
|
||||
|
||||
async fn begin_transaction<'a>(
|
||||
&'a self,
|
||||
) -> Result<Box<dyn MintAuthTransaction<database::Error> + Send + Sync + 'a>, database::Error>
|
||||
{
|
||||
Ok(Box::new(SqliteTransaction {
|
||||
inner: self.pool.begin().await?,
|
||||
}))
|
||||
}
|
||||
|
||||
async fn get_active_keyset_id(&self) -> Result<Option<Id>, Self::Err> {
|
||||
Ok(query(
|
||||
r#"
|
||||
SELECT
|
||||
id
|
||||
FROM
|
||||
keyset
|
||||
WHERE
|
||||
active = 1;
|
||||
"#,
|
||||
)
|
||||
.pluck(&self.pool)
|
||||
.await?
|
||||
.map(|id| Ok::<_, Error>(column_as_string!(id, Id::from_str, Id::from_bytes)))
|
||||
.transpose()?)
|
||||
}
|
||||
|
||||
async fn get_keyset_info(&self, id: &Id) -> Result<Option<MintKeySetInfo>, Self::Err> {
|
||||
Ok(query(
|
||||
r#"SELECT
|
||||
id,
|
||||
unit,
|
||||
active,
|
||||
valid_from,
|
||||
valid_to,
|
||||
derivation_path,
|
||||
derivation_path_index,
|
||||
max_order,
|
||||
input_fee_ppk
|
||||
FROM
|
||||
keyset
|
||||
WHERE id=:id"#,
|
||||
)
|
||||
.bind(":id", id.to_string())
|
||||
.fetch_one(&self.pool)
|
||||
.await?
|
||||
.map(sqlite_row_to_keyset_info)
|
||||
.transpose()?)
|
||||
}
|
||||
|
||||
async fn get_keyset_infos(&self) -> Result<Vec<MintKeySetInfo>, Self::Err> {
|
||||
Ok(query(
|
||||
r#"SELECT
|
||||
id,
|
||||
unit,
|
||||
active,
|
||||
valid_from,
|
||||
valid_to,
|
||||
derivation_path,
|
||||
derivation_path_index,
|
||||
max_order,
|
||||
input_fee_ppk
|
||||
FROM
|
||||
keyset
|
||||
WHERE id=:id"#,
|
||||
)
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(sqlite_row_to_keyset_info)
|
||||
.collect::<Result<Vec<_>, _>>()?)
|
||||
}
|
||||
|
||||
async fn get_proofs_states(&self, ys: &[PublicKey]) -> Result<Vec<Option<State>>, Self::Err> {
|
||||
let mut current_states = query(r#"SELECT y, state FROM proof WHERE y IN (:ys)"#)
|
||||
.bind_vec(":ys", ys.iter().map(|y| y.to_bytes().to_vec()).collect())
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|row| {
|
||||
Ok((
|
||||
column_as_string!(&row[0], PublicKey::from_hex, PublicKey::from_slice),
|
||||
column_as_string!(&row[1], State::from_str),
|
||||
))
|
||||
})
|
||||
.collect::<Result<HashMap<_, _>, Error>>()?;
|
||||
|
||||
Ok(ys.iter().map(|y| current_states.remove(y)).collect())
|
||||
}
|
||||
|
||||
async fn get_blind_signatures(
|
||||
&self,
|
||||
blinded_messages: &[PublicKey],
|
||||
) -> Result<Vec<Option<BlindSignature>>, Self::Err> {
|
||||
let mut blinded_signatures = query(
|
||||
r#"SELECT
|
||||
keyset_id,
|
||||
amount,
|
||||
c,
|
||||
dleq_e,
|
||||
dleq_s,
|
||||
y
|
||||
FROM
|
||||
blind_signature
|
||||
WHERE y IN (:y)
|
||||
"#,
|
||||
)
|
||||
.bind_vec(
|
||||
":y",
|
||||
blinded_messages
|
||||
.iter()
|
||||
.map(|y| y.to_bytes().to_vec())
|
||||
.collect(),
|
||||
)
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|mut row| {
|
||||
Ok((
|
||||
column_as_string!(
|
||||
&row.pop().ok_or(Error::InvalidDbResponse)?,
|
||||
PublicKey::from_hex,
|
||||
PublicKey::from_slice
|
||||
),
|
||||
sqlite_row_to_blind_signature(row)?,
|
||||
))
|
||||
})
|
||||
.collect::<Result<HashMap<_, _>, Error>>()?;
|
||||
Ok(blinded_messages
|
||||
.iter()
|
||||
.map(|y| blinded_signatures.remove(y))
|
||||
.collect())
|
||||
}
|
||||
|
||||
async fn get_auth_for_endpoint(
|
||||
&self,
|
||||
protected_endpoint: ProtectedEndpoint,
|
||||
) -> Result<Option<AuthRequired>, Self::Err> {
|
||||
Ok(
|
||||
query(r#"SELECT auth FROM protected_endpoints WHERE endpoint = :endpoint"#)
|
||||
.bind(":endpoint", serde_json::to_string(&protected_endpoint)?)
|
||||
.pluck(&self.pool)
|
||||
.await?
|
||||
.map(|auth| {
|
||||
Ok::<_, Error>(column_as_string!(
|
||||
auth,
|
||||
serde_json::from_str,
|
||||
serde_json::from_slice
|
||||
))
|
||||
})
|
||||
.transpose()?,
|
||||
)
|
||||
}
|
||||
|
||||
async fn get_auth_for_endpoints(
|
||||
&self,
|
||||
) -> Result<HashMap<ProtectedEndpoint, Option<AuthRequired>>, Self::Err> {
|
||||
Ok(query(r#"SELECT endpoint, auth FROM protected_endpoints"#)
|
||||
.fetch_all(&self.pool)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|row| {
|
||||
let endpoint =
|
||||
column_as_string!(&row[0], serde_json::from_str, serde_json::from_slice);
|
||||
let auth = column_as_string!(&row[1], serde_json::from_str, serde_json::from_slice);
|
||||
Ok((endpoint, Some(auth)))
|
||||
})
|
||||
.collect::<Result<HashMap<_, _>, Error>>()?)
|
||||
}
|
||||
}
|
||||
@@ -1,116 +0,0 @@
|
||||
//! SQLite Database Error
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
/// SQLite Database Error
|
||||
#[derive(Debug, Error)]
|
||||
pub enum Error {
|
||||
/// SQLX Error
|
||||
#[error(transparent)]
|
||||
Sqlite(#[from] rusqlite::Error),
|
||||
|
||||
/// Duplicate entry
|
||||
#[error("Record already exists")]
|
||||
Duplicate,
|
||||
|
||||
/// Pool error
|
||||
#[error(transparent)]
|
||||
Pool(#[from] crate::pool::Error<rusqlite::Error>),
|
||||
/// Invalid UUID
|
||||
#[error("Invalid UUID: {0}")]
|
||||
InvalidUuid(String),
|
||||
/// QuoteNotFound
|
||||
#[error("Quote not found")]
|
||||
QuoteNotFound,
|
||||
|
||||
/// Missing named parameter
|
||||
#[error("Missing named parameter {0}")]
|
||||
MissingParameter(String),
|
||||
|
||||
/// Communication error with the database
|
||||
#[error("Internal communication error")]
|
||||
Communication,
|
||||
|
||||
/// Invalid response from the database thread
|
||||
#[error("Unexpected database response")]
|
||||
InvalidDbResponse,
|
||||
|
||||
/// Invalid db type
|
||||
#[error("Invalid type from db, expected {0} got {1}")]
|
||||
InvalidType(String, String),
|
||||
|
||||
/// Missing columns
|
||||
#[error("Not enough elements: expected {0}, got {1}")]
|
||||
MissingColumn(usize, usize),
|
||||
|
||||
/// Invalid data conversion in column
|
||||
#[error("Error converting {0} to {1}")]
|
||||
InvalidConversion(String, String),
|
||||
|
||||
/// NUT00 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT00(#[from] cdk_common::nuts::nut00::Error),
|
||||
/// NUT01 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT01(#[from] cdk_common::nuts::nut01::Error),
|
||||
/// NUT02 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT02(#[from] cdk_common::nuts::nut02::Error),
|
||||
/// NUT04 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT04(#[from] cdk_common::nuts::nut04::Error),
|
||||
/// NUT05 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT05(#[from] cdk_common::nuts::nut05::Error),
|
||||
/// NUT07 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT07(#[from] cdk_common::nuts::nut07::Error),
|
||||
/// NUT23 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT23(#[from] cdk_common::nuts::nut23::Error),
|
||||
/// Secret Error
|
||||
#[error(transparent)]
|
||||
CDKSECRET(#[from] cdk_common::secret::Error),
|
||||
/// BIP32 Error
|
||||
#[error(transparent)]
|
||||
BIP32(#[from] bitcoin::bip32::Error),
|
||||
/// Mint Url Error
|
||||
#[error(transparent)]
|
||||
MintUrl(#[from] cdk_common::mint_url::Error),
|
||||
/// Could Not Initialize Database
|
||||
#[error("Could not initialize database")]
|
||||
CouldNotInitialize,
|
||||
/// Invalid Database Path
|
||||
#[error("Invalid database path")]
|
||||
InvalidDbPath,
|
||||
/// Serde Error
|
||||
#[error(transparent)]
|
||||
Serde(#[from] serde_json::Error),
|
||||
/// Unknown Mint Info
|
||||
#[error("Unknown mint info")]
|
||||
UnknownMintInfo,
|
||||
/// Unknown quote TTL
|
||||
#[error("Unknown quote TTL")]
|
||||
UnknownQuoteTTL,
|
||||
/// Unknown config key
|
||||
#[error("Unknown config key: {0}")]
|
||||
UnknownConfigKey(String),
|
||||
/// Proof not found
|
||||
#[error("Proof not found")]
|
||||
ProofNotFound,
|
||||
/// Invalid keyset ID
|
||||
#[error("Invalid keyset ID")]
|
||||
InvalidKeysetId,
|
||||
/// Invalid melt payment request
|
||||
#[error("Invalid melt payment request")]
|
||||
InvalidMeltPaymentRequest,
|
||||
}
|
||||
|
||||
impl From<Error> for cdk_common::database::Error {
|
||||
fn from(e: Error) -> Self {
|
||||
match e {
|
||||
Error::Duplicate => Self::Duplicate,
|
||||
e => Self::Database(Box::new(e)),
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -11,10 +11,11 @@ use super::MintSqliteDatabase;
|
||||
/// Creates a new in-memory [`MintSqliteDatabase`] instance
|
||||
pub async fn empty() -> Result<MintSqliteDatabase, database::Error> {
|
||||
#[cfg(not(feature = "sqlcipher"))]
|
||||
let db = MintSqliteDatabase::new(":memory:").await?;
|
||||
let path = ":memory:";
|
||||
#[cfg(feature = "sqlcipher")]
|
||||
let db = MintSqliteDatabase::new(":memory:", "memory".to_string()).await?;
|
||||
Ok(db)
|
||||
let path = (":memory:", "memory");
|
||||
|
||||
MintSqliteDatabase::new(path).await
|
||||
}
|
||||
|
||||
/// Creates a new in-memory [`MintSqliteDatabase`] instance with the given state
|
||||
|
||||
@@ -1,25 +0,0 @@
|
||||
// @generated
|
||||
// Auto-generated by build.rs
|
||||
pub static MIGRATIONS: &[(&str, &str)] = &[
|
||||
("20240612124932_init.sql", include_str!(r#"./migrations/20240612124932_init.sql"#)),
|
||||
("20240618195700_quote_state.sql", include_str!(r#"./migrations/20240618195700_quote_state.sql"#)),
|
||||
("20240626092101_nut04_state.sql", include_str!(r#"./migrations/20240626092101_nut04_state.sql"#)),
|
||||
("20240703122347_request_lookup_id.sql", include_str!(r#"./migrations/20240703122347_request_lookup_id.sql"#)),
|
||||
("20240710145043_input_fee.sql", include_str!(r#"./migrations/20240710145043_input_fee.sql"#)),
|
||||
("20240711183109_derivation_path_index.sql", include_str!(r#"./migrations/20240711183109_derivation_path_index.sql"#)),
|
||||
("20240718203721_allow_unspent.sql", include_str!(r#"./migrations/20240718203721_allow_unspent.sql"#)),
|
||||
("20240811031111_update_mint_url.sql", include_str!(r#"./migrations/20240811031111_update_mint_url.sql"#)),
|
||||
("20240919103407_proofs_quote_id.sql", include_str!(r#"./migrations/20240919103407_proofs_quote_id.sql"#)),
|
||||
("20240923153640_melt_requests.sql", include_str!(r#"./migrations/20240923153640_melt_requests.sql"#)),
|
||||
("20240930101140_dleq_for_sigs.sql", include_str!(r#"./migrations/20240930101140_dleq_for_sigs.sql"#)),
|
||||
("20241108093102_mint_mint_quote_pubkey.sql", include_str!(r#"./migrations/20241108093102_mint_mint_quote_pubkey.sql"#)),
|
||||
("20250103201327_amount_to_pay_msats.sql", include_str!(r#"./migrations/20250103201327_amount_to_pay_msats.sql"#)),
|
||||
("20250129200912_remove_mint_url.sql", include_str!(r#"./migrations/20250129200912_remove_mint_url.sql"#)),
|
||||
("20250129230326_add_config_table.sql", include_str!(r#"./migrations/20250129230326_add_config_table.sql"#)),
|
||||
("20250307213652_keyset_id_as_foreign_key.sql", include_str!(r#"./migrations/20250307213652_keyset_id_as_foreign_key.sql"#)),
|
||||
("20250406091754_mint_time_of_quotes.sql", include_str!(r#"./migrations/20250406091754_mint_time_of_quotes.sql"#)),
|
||||
("20250406093755_mint_created_time_signature.sql", include_str!(r#"./migrations/20250406093755_mint_created_time_signature.sql"#)),
|
||||
("20250415093121_drop_keystore_foreign.sql", include_str!(r#"./migrations/20250415093121_drop_keystore_foreign.sql"#)),
|
||||
("20250626120251_rename_blind_message_y_to_b.sql", include_str!(r#"./migrations/20250626120251_rename_blind_message_y_to_b.sql"#)),
|
||||
("20250706101057_bolt12.sql", include_str!(r#"./migrations/20250706101057_bolt12.sql"#)),
|
||||
];
|
||||
@@ -1,68 +0,0 @@
|
||||
|
||||
-- Proof Table
|
||||
CREATE TABLE IF NOT EXISTS proof (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT,
|
||||
state TEXT CHECK ( state IN ('SPENT', 'PENDING' ) ) NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS state_index ON proof(state);
|
||||
CREATE INDEX IF NOT EXISTS secret_index ON proof(secret);
|
||||
|
||||
-- Keysets Table
|
||||
|
||||
CREATE TABLE IF NOT EXISTS keyset (
|
||||
id TEXT PRIMARY KEY,
|
||||
unit TEXT NOT NULL,
|
||||
active BOOL NOT NULL,
|
||||
valid_from INTEGER NOT NULL,
|
||||
valid_to INTEGER,
|
||||
derivation_path TEXT NOT NULL,
|
||||
max_order INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS unit_index ON keyset(unit);
|
||||
CREATE INDEX IF NOT EXISTS active_index ON keyset(active);
|
||||
|
||||
|
||||
CREATE TABLE IF NOT EXISTS mint_quote (
|
||||
id TEXT PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
unit TEXT NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
paid BOOL NOT NULL DEFAULT FALSE,
|
||||
expiry INTEGER NOT NULL
|
||||
);
|
||||
|
||||
|
||||
CREATE INDEX IF NOT EXISTS paid_index ON mint_quote(paid);
|
||||
CREATE INDEX IF NOT EXISTS request_index ON mint_quote(request);
|
||||
CREATE INDEX IF NOT EXISTS expiry_index ON mint_quote(expiry);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS melt_quote (
|
||||
id TEXT PRIMARY KEY,
|
||||
unit TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
fee_reserve INTEGER NOT NULL,
|
||||
paid BOOL NOT NULL DEFAULT FALSE,
|
||||
expiry INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS paid_index ON melt_quote(paid);
|
||||
CREATE INDEX IF NOT EXISTS request_index ON melt_quote(request);
|
||||
CREATE INDEX IF NOT EXISTS expiry_index ON melt_quote(expiry);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS blind_signature (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
c BLOB NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS keyset_id_index ON blind_signature(keyset_id);
|
||||
@@ -1,5 +0,0 @@
|
||||
ALTER TABLE melt_quote ADD state TEXT CHECK ( state IN ('UNPAID', 'PENDING', 'PAID' ) ) NOT NULL DEFAULT 'UNPAID';
|
||||
ALTER TABLE melt_quote ADD payment_preimage TEXT;
|
||||
ALTER TABLE melt_quote DROP COLUMN paid;
|
||||
CREATE INDEX IF NOT EXISTS melt_quote_state_index ON melt_quote(state);
|
||||
DROP INDEX IF EXISTS paid_index;
|
||||
@@ -1,3 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD state TEXT CHECK ( state IN ('UNPAID', 'PENDING', 'PAID', 'ISSUED' ) ) NOT NULL DEFAULT 'UNPAID';
|
||||
ALTER TABLE mint_quote DROP COLUMN paid;
|
||||
CREATE INDEX IF NOT EXISTS mint_quote_state_index ON mint_quote(state);
|
||||
@@ -1,5 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD COLUMN request_lookup_id TEXT;
|
||||
ALTER TABLE melt_quote ADD COLUMN request_lookup_id TEXT;
|
||||
|
||||
CREATE UNIQUE INDEX unique_request_lookup_id_mint ON mint_quote(request_lookup_id);
|
||||
CREATE UNIQUE INDEX unique_request_lookup_id_melt ON melt_quote(request_lookup_id);
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE keyset ADD input_fee_ppk INTEGER;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE keyset ADD derivation_path_index INTEGER;
|
||||
@@ -1,21 +0,0 @@
|
||||
-- Create a new table with the updated CHECK constraint
|
||||
CREATE TABLE proof_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT,
|
||||
state TEXT CHECK (state IN ('SPENT', 'PENDING', 'UNSPENT')) NOT NULL
|
||||
);
|
||||
|
||||
-- Copy the data from the old table to the new table
|
||||
INSERT INTO proof_new (y, amount, keyset_id, secret, c, witness, state)
|
||||
SELECT y, amount, keyset_id, secret, c, witness, state
|
||||
FROM proof;
|
||||
|
||||
-- Drop the old table
|
||||
DROP TABLE proof;
|
||||
|
||||
-- Rename the new table to the original table name
|
||||
ALTER TABLE proof_new RENAME TO proof;
|
||||
@@ -1 +0,0 @@
|
||||
UPDATE `mint_quote` SET `mint_url` = RTRIM(`mint_url`, '/');
|
||||
@@ -1,2 +0,0 @@
|
||||
ALTER TABLE proof ADD COLUMN quote_id TEXT;
|
||||
ALTER TABLE blind_signature ADD COLUMN quote_id TEXT;
|
||||
@@ -1,8 +0,0 @@
|
||||
-- Melt Request Table
|
||||
CREATE TABLE IF NOT EXISTS melt_request (
|
||||
id TEXT PRIMARY KEY,
|
||||
inputs TEXT NOT NULL,
|
||||
outputs TEXT,
|
||||
method TEXT NOT NULL,
|
||||
unit TEXT NOT NULL
|
||||
);
|
||||
@@ -1,2 +0,0 @@
|
||||
ALTER TABLE blind_signature ADD COLUMN dleq_e TEXT;
|
||||
ALTER TABLE blind_signature ADD COLUMN dleq_s TEXT;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD pubkey TEXT;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE melt_quote ADD COLUMN msat_to_pay INTEGER;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint_quote DROP COLUMN mint_url;
|
||||
@@ -1,4 +0,0 @@
|
||||
CREATE TABLE IF NOT EXISTS config (
|
||||
id TEXT PRIMARY KEY,
|
||||
value TEXT NOT NULL
|
||||
);
|
||||
@@ -1,51 +0,0 @@
|
||||
-- Add foreign key constraints for keyset_id in SQLite
|
||||
-- SQLite requires recreating tables to add foreign keys
|
||||
|
||||
-- First, ensure we have the right schema information
|
||||
PRAGMA foreign_keys = OFF;
|
||||
|
||||
-- Create new proof table with foreign key constraint
|
||||
CREATE TABLE proof_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL REFERENCES keyset(id),
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT,
|
||||
state TEXT CHECK (state IN ('SPENT', 'PENDING', 'UNSPENT', 'RESERVED', 'UNKNOWN')) NOT NULL,
|
||||
quote_id TEXT
|
||||
);
|
||||
|
||||
-- Copy data from old proof table to new one
|
||||
INSERT INTO proof_new SELECT * FROM proof;
|
||||
|
||||
-- Create new blind_signature table with foreign key constraint
|
||||
CREATE TABLE blind_signature_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL REFERENCES keyset(id),
|
||||
c BLOB NOT NULL,
|
||||
dleq_e TEXT,
|
||||
dleq_s TEXT,
|
||||
quote_id TEXT
|
||||
);
|
||||
|
||||
-- Copy data from old blind_signature table to new one
|
||||
INSERT INTO blind_signature_new SELECT * FROM blind_signature;
|
||||
|
||||
-- Drop old tables
|
||||
DROP TABLE IF EXISTS proof;
|
||||
DROP TABLE IF EXISTS blind_signature;
|
||||
|
||||
-- Rename new tables to original names
|
||||
ALTER TABLE proof_new RENAME TO proof;
|
||||
ALTER TABLE blind_signature_new RENAME TO blind_signature;
|
||||
|
||||
-- Recreate all indexes
|
||||
CREATE INDEX IF NOT EXISTS proof_keyset_id_index ON proof(keyset_id);
|
||||
CREATE INDEX IF NOT EXISTS state_index ON proof(state);
|
||||
CREATE INDEX IF NOT EXISTS secret_index ON proof(secret);
|
||||
CREATE INDEX IF NOT EXISTS blind_signature_keyset_id_index ON blind_signature(keyset_id);
|
||||
|
||||
-- Re-enable foreign keys
|
||||
PRAGMA foreign_keys = ON;
|
||||
@@ -1,8 +0,0 @@
|
||||
-- Add timestamp columns to mint_quote table
|
||||
ALTER TABLE mint_quote ADD COLUMN created_time INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE mint_quote ADD COLUMN paid_time INTEGER;
|
||||
ALTER TABLE mint_quote ADD COLUMN issued_time INTEGER;
|
||||
|
||||
-- Add timestamp columns to melt_quote table
|
||||
ALTER TABLE melt_quote ADD COLUMN created_time INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE melt_quote ADD COLUMN paid_time INTEGER;
|
||||
@@ -1,4 +0,0 @@
|
||||
-- Add created_time column to blind_signature table
|
||||
ALTER TABLE blind_signature ADD COLUMN created_time INTEGER NOT NULL DEFAULT 0;
|
||||
-- Add created_time column to proof table
|
||||
ALTER TABLE proof ADD COLUMN created_time INTEGER NOT NULL DEFAULT 0;
|
||||
@@ -1,31 +0,0 @@
|
||||
CREATE TABLE proof_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL, -- no FK constraint here
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT,
|
||||
state TEXT CHECK (state IN ('SPENT', 'PENDING', 'UNSPENT', 'RESERVED', 'UNKNOWN')) NOT NULL,
|
||||
quote_id TEXT,
|
||||
created_time INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
|
||||
INSERT INTO proof_new SELECT * FROM proof;
|
||||
DROP TABLE proof;
|
||||
ALTER TABLE proof_new RENAME TO proof;
|
||||
|
||||
|
||||
CREATE TABLE blind_signature_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL, -- FK removed
|
||||
c BLOB NOT NULL,
|
||||
dleq_e TEXT,
|
||||
dleq_s TEXT,
|
||||
quote_id TEXT,
|
||||
created_time INTEGER NOT NULL DEFAULT 0
|
||||
);
|
||||
|
||||
INSERT INTO blind_signature_new SELECT * FROM blind_signature;
|
||||
DROP TABLE blind_signature;
|
||||
ALTER TABLE blind_signature_new RENAME TO blind_signature;
|
||||
@@ -1,2 +0,0 @@
|
||||
-- Rename column y to b
|
||||
ALTER TABLE blind_signature RENAME COLUMN y TO blinded_message;
|
||||
@@ -1,81 +0,0 @@
|
||||
-- Add new columns to mint_quote table
|
||||
ALTER TABLE mint_quote ADD COLUMN amount_paid INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE mint_quote ADD COLUMN amount_issued INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE mint_quote ADD COLUMN payment_method TEXT NOT NULL DEFAULT 'BOLT11';
|
||||
ALTER TABLE mint_quote DROP COLUMN issued_time;
|
||||
ALTER TABLE mint_quote DROP COLUMN paid_time;
|
||||
|
||||
-- Set amount_paid equal to amount for quotes with PAID or ISSUED state
|
||||
UPDATE mint_quote SET amount_paid = amount WHERE state = 'PAID' OR state = 'ISSUED';
|
||||
|
||||
-- Set amount_issued equal to amount for quotes with ISSUED state
|
||||
UPDATE mint_quote SET amount_issued = amount WHERE state = 'ISSUED';
|
||||
|
||||
DROP INDEX IF EXISTS mint_quote_state_index;
|
||||
|
||||
-- Remove the state column from mint_quote table
|
||||
ALTER TABLE mint_quote DROP COLUMN state;
|
||||
|
||||
-- Remove NOT NULL constraint from amount column
|
||||
CREATE TABLE mint_quote_temp (
|
||||
id TEXT PRIMARY KEY,
|
||||
amount INTEGER,
|
||||
unit TEXT NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
expiry INTEGER NOT NULL,
|
||||
request_lookup_id TEXT UNIQUE,
|
||||
pubkey TEXT,
|
||||
created_time INTEGER NOT NULL DEFAULT 0,
|
||||
amount_paid INTEGER NOT NULL DEFAULT 0,
|
||||
amount_issued INTEGER NOT NULL DEFAULT 0,
|
||||
payment_method TEXT NOT NULL DEFAULT 'BOLT11'
|
||||
);
|
||||
|
||||
INSERT INTO mint_quote_temp (id, amount, unit, request, expiry, request_lookup_id, pubkey, created_time, amount_paid, amount_issued, payment_method)
|
||||
SELECT id, amount, unit, request, expiry, request_lookup_id, pubkey, created_time, amount_paid, amount_issued, payment_method
|
||||
FROM mint_quote;
|
||||
|
||||
DROP TABLE mint_quote;
|
||||
ALTER TABLE mint_quote_temp RENAME TO mint_quote;
|
||||
|
||||
ALTER TABLE mint_quote ADD COLUMN request_lookup_id_kind TEXT NOT NULL DEFAULT 'payment_hash';
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_mint_quote_created_time ON mint_quote(created_time);
|
||||
CREATE INDEX IF NOT EXISTS idx_mint_quote_expiry ON mint_quote(expiry);
|
||||
CREATE INDEX IF NOT EXISTS idx_mint_quote_request_lookup_id ON mint_quote(request_lookup_id);
|
||||
CREATE INDEX IF NOT EXISTS idx_mint_quote_request_lookup_id_and_kind ON mint_quote(request_lookup_id, request_lookup_id_kind);
|
||||
|
||||
-- Create mint_quote_payments table
|
||||
CREATE TABLE mint_quote_payments (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
quote_id TEXT NOT NULL,
|
||||
payment_id TEXT NOT NULL UNIQUE,
|
||||
timestamp INTEGER NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
FOREIGN KEY (quote_id) REFERENCES mint_quote(id)
|
||||
);
|
||||
|
||||
-- Create index on payment_id for faster lookups
|
||||
CREATE INDEX idx_mint_quote_payments_payment_id ON mint_quote_payments(payment_id);
|
||||
CREATE INDEX idx_mint_quote_payments_quote_id ON mint_quote_payments(quote_id);
|
||||
|
||||
-- Create mint_quote_issued table
|
||||
CREATE TABLE mint_quote_issued (
|
||||
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
quote_id TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
timestamp INTEGER NOT NULL,
|
||||
FOREIGN KEY (quote_id) REFERENCES mint_quote(id)
|
||||
);
|
||||
|
||||
-- Create index on quote_id for faster lookups
|
||||
CREATE INDEX idx_mint_quote_issued_quote_id ON mint_quote_issued(quote_id);
|
||||
|
||||
-- Add new columns to melt_quote table
|
||||
ALTER TABLE melt_quote ADD COLUMN payment_method TEXT NOT NULL DEFAULT 'bolt11';
|
||||
ALTER TABLE melt_quote ADD COLUMN options TEXT;
|
||||
ALTER TABLE melt_quote ADD COLUMN request_lookup_id_kind TEXT NOT NULL DEFAULT 'payment_hash';
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_melt_quote_request_lookup_id_and_kind ON mint_quote(request_lookup_id, request_lookup_id_kind);
|
||||
|
||||
ALTER TABLE melt_quote DROP COLUMN msat_to_pay;
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,196 +0,0 @@
|
||||
//! Very simple connection pool, to avoid an external dependency on r2d2 and other crates. If this
|
||||
//! endup work it can be re-used in other parts of the project and may be promoted to its own
|
||||
//! generic crate
|
||||
|
||||
use std::fmt::Debug;
|
||||
use std::ops::{Deref, DerefMut};
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Condvar, Mutex};
|
||||
use std::time::Duration;
|
||||
|
||||
/// Pool error
|
||||
#[derive(thiserror::Error, Debug)]
|
||||
pub enum Error<E> {
|
||||
/// Mutex Poison Error
|
||||
#[error("Internal: PoisonError")]
|
||||
Poison,
|
||||
|
||||
/// Timeout error
|
||||
#[error("Timed out waiting for a resource")]
|
||||
Timeout,
|
||||
|
||||
/// Internal database error
|
||||
#[error(transparent)]
|
||||
Resource(#[from] E),
|
||||
}
|
||||
|
||||
/// Trait to manage resources
|
||||
pub trait ResourceManager: Debug {
|
||||
/// The resource to be pooled
|
||||
type Resource: Debug;
|
||||
|
||||
/// The configuration that is needed in order to create the resource
|
||||
type Config: Debug;
|
||||
|
||||
/// The error the resource may return when creating a new instance
|
||||
type Error: Debug;
|
||||
|
||||
/// Creates a new resource with a given config
|
||||
fn new_resource(config: &Self::Config) -> Result<Self::Resource, Error<Self::Error>>;
|
||||
|
||||
/// The object is dropped
|
||||
fn drop(_resource: Self::Resource) {}
|
||||
}
|
||||
|
||||
/// Generic connection pool of resources R
|
||||
#[derive(Debug)]
|
||||
pub struct Pool<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
config: RM::Config,
|
||||
queue: Mutex<Vec<RM::Resource>>,
|
||||
in_use: AtomicUsize,
|
||||
max_size: usize,
|
||||
default_timeout: Duration,
|
||||
waiter: Condvar,
|
||||
}
|
||||
|
||||
/// The pooled resource
|
||||
pub struct PooledResource<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
resource: Option<RM::Resource>,
|
||||
pool: Arc<Pool<RM>>,
|
||||
}
|
||||
|
||||
impl<RM> Drop for PooledResource<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
fn drop(&mut self) {
|
||||
if let Some(resource) = self.resource.take() {
|
||||
let mut active_resource = self.pool.queue.lock().expect("active_resource");
|
||||
active_resource.push(resource);
|
||||
self.pool.in_use.fetch_sub(1, Ordering::AcqRel);
|
||||
|
||||
// Notify a waiting thread
|
||||
self.pool.waiter.notify_one();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<RM> Deref for PooledResource<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
type Target = RM::Resource;
|
||||
|
||||
fn deref(&self) -> &Self::Target {
|
||||
self.resource.as_ref().expect("resource already dropped")
|
||||
}
|
||||
}
|
||||
|
||||
impl<RM> DerefMut for PooledResource<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||
self.resource.as_mut().expect("resource already dropped")
|
||||
}
|
||||
}
|
||||
|
||||
impl<RM> Pool<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
/// Creates a new pool
|
||||
pub fn new(config: RM::Config, max_size: usize, default_timeout: Duration) -> Arc<Self> {
|
||||
Arc::new(Self {
|
||||
config,
|
||||
queue: Default::default(),
|
||||
in_use: Default::default(),
|
||||
waiter: Default::default(),
|
||||
default_timeout,
|
||||
max_size,
|
||||
})
|
||||
}
|
||||
|
||||
/// Similar to get_timeout but uses the default timeout value.
|
||||
#[inline(always)]
|
||||
pub fn get(self: &Arc<Self>) -> Result<PooledResource<RM>, Error<RM::Error>> {
|
||||
self.get_timeout(self.default_timeout)
|
||||
}
|
||||
|
||||
/// Get a new resource or fail after timeout is reached.
|
||||
///
|
||||
/// This function will return a free resource or create a new one if there is still room for it;
|
||||
/// otherwise, it will wait for a resource to be released for reuse.
|
||||
#[inline(always)]
|
||||
pub fn get_timeout(
|
||||
self: &Arc<Self>,
|
||||
timeout: Duration,
|
||||
) -> Result<PooledResource<RM>, Error<RM::Error>> {
|
||||
let mut resources = self.queue.lock().map_err(|_| Error::Poison)?;
|
||||
|
||||
loop {
|
||||
if let Some(resource) = resources.pop() {
|
||||
drop(resources);
|
||||
self.in_use.fetch_add(1, Ordering::AcqRel);
|
||||
|
||||
return Ok(PooledResource {
|
||||
resource: Some(resource),
|
||||
pool: self.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
if self.in_use.load(Ordering::Relaxed) < self.max_size {
|
||||
drop(resources);
|
||||
self.in_use.fetch_add(1, Ordering::AcqRel);
|
||||
|
||||
return Ok(PooledResource {
|
||||
resource: Some(RM::new_resource(&self.config)?),
|
||||
pool: self.clone(),
|
||||
});
|
||||
}
|
||||
|
||||
resources = self
|
||||
.waiter
|
||||
.wait_timeout(resources, timeout)
|
||||
.map_err(|_| Error::Poison)
|
||||
.and_then(|(lock, timeout_result)| {
|
||||
if timeout_result.timed_out() {
|
||||
Err(Error::Timeout)
|
||||
} else {
|
||||
Ok(lock)
|
||||
}
|
||||
})?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<RM> Drop for Pool<RM>
|
||||
where
|
||||
RM: ResourceManager,
|
||||
{
|
||||
fn drop(&mut self) {
|
||||
if let Ok(mut resources) = self.queue.lock() {
|
||||
loop {
|
||||
while let Some(resource) = resources.pop() {
|
||||
RM::drop(resource);
|
||||
}
|
||||
|
||||
if self.in_use.load(Ordering::Relaxed) == 0 {
|
||||
break;
|
||||
}
|
||||
|
||||
resources = if let Ok(resources) = self.waiter.wait(resources) {
|
||||
resources
|
||||
} else {
|
||||
break;
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
use std::collections::HashMap;
|
||||
|
||||
use rusqlite::{self, CachedStatement};
|
||||
|
||||
use crate::common::SqliteConnectionManager;
|
||||
use crate::pool::PooledResource;
|
||||
|
||||
/// The Value coming from SQLite
|
||||
pub type Value = rusqlite::types::Value;
|
||||
|
||||
/// The Column type
|
||||
pub type Column = Value;
|
||||
|
||||
/// Expected response type for a given SQL statement
|
||||
#[derive(Debug, Clone, Copy, Default)]
|
||||
pub enum ExpectedSqlResponse {
|
||||
/// A single row
|
||||
SingleRow,
|
||||
/// All the rows that matches a query
|
||||
#[default]
|
||||
ManyRows,
|
||||
/// How many rows were affected by the query
|
||||
AffectedRows,
|
||||
/// Return the first column of the first row
|
||||
Pluck,
|
||||
}
|
||||
|
||||
/// Sql message
|
||||
#[derive(Default, Debug)]
|
||||
pub struct Statement {
|
||||
/// The SQL statement
|
||||
pub sql: String,
|
||||
/// The list of arguments for the placeholders. It only supports named arguments for simplicity
|
||||
/// sake
|
||||
pub args: HashMap<String, Value>,
|
||||
/// The expected response type
|
||||
pub expected_response: ExpectedSqlResponse,
|
||||
}
|
||||
|
||||
impl Statement {
|
||||
/// Creates a new statement
|
||||
pub fn new<T>(sql: T) -> Self
|
||||
where
|
||||
T: ToString,
|
||||
{
|
||||
Self {
|
||||
sql: sql.to_string(),
|
||||
..Default::default()
|
||||
}
|
||||
}
|
||||
|
||||
/// Binds a given placeholder to a value.
|
||||
#[inline]
|
||||
pub fn bind<C, V>(mut self, name: C, value: V) -> Self
|
||||
where
|
||||
C: ToString,
|
||||
V: Into<Value>,
|
||||
{
|
||||
self.args.insert(name.to_string(), value.into());
|
||||
self
|
||||
}
|
||||
|
||||
/// Binds a single variable with a vector.
|
||||
///
|
||||
/// This will rewrite the function from `:foo` (where value is vec![1, 2, 3]) to `:foo0, :foo1,
|
||||
/// :foo2` and binds each value from the value vector accordingly.
|
||||
#[inline]
|
||||
pub fn bind_vec<C, V>(mut self, name: C, value: Vec<V>) -> Self
|
||||
where
|
||||
C: ToString,
|
||||
V: Into<Value>,
|
||||
{
|
||||
let mut new_sql = String::with_capacity(self.sql.len());
|
||||
let target = name.to_string();
|
||||
let mut i = 0;
|
||||
|
||||
let placeholders = value
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
.map(|(key, value)| {
|
||||
let key = format!("{target}{key}");
|
||||
self.args.insert(key.clone(), value.into());
|
||||
key
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(",");
|
||||
|
||||
while let Some(pos) = self.sql[i..].find(&target) {
|
||||
let abs_pos = i + pos;
|
||||
let after = abs_pos + target.len();
|
||||
let is_word_boundary = self.sql[after..]
|
||||
.chars()
|
||||
.next()
|
||||
.map_or(true, |c| !c.is_alphanumeric() && c != '_');
|
||||
|
||||
if is_word_boundary {
|
||||
new_sql.push_str(&self.sql[i..abs_pos]);
|
||||
new_sql.push_str(&placeholders);
|
||||
i = after;
|
||||
} else {
|
||||
new_sql.push_str(&self.sql[i..=abs_pos]);
|
||||
i = abs_pos + 1;
|
||||
}
|
||||
}
|
||||
|
||||
new_sql.push_str(&self.sql[i..]);
|
||||
|
||||
self.sql = new_sql;
|
||||
self
|
||||
}
|
||||
|
||||
fn get_stmt(
|
||||
self,
|
||||
conn: &PooledResource<SqliteConnectionManager>,
|
||||
) -> rusqlite::Result<CachedStatement<'_>> {
|
||||
let mut stmt = conn.prepare_cached(&self.sql)?;
|
||||
for (name, value) in self.args {
|
||||
let index = stmt
|
||||
.parameter_index(&name)
|
||||
.map_err(|_| rusqlite::Error::InvalidColumnName(name.clone()))?
|
||||
.ok_or(rusqlite::Error::InvalidColumnName(name))?;
|
||||
|
||||
stmt.raw_bind_parameter(index, value)?;
|
||||
}
|
||||
|
||||
Ok(stmt)
|
||||
}
|
||||
|
||||
/// Executes a query and returns the affected rows
|
||||
pub fn plunk(
|
||||
self,
|
||||
conn: &PooledResource<SqliteConnectionManager>,
|
||||
) -> rusqlite::Result<Option<Value>> {
|
||||
let mut stmt = self.get_stmt(conn)?;
|
||||
let mut rows = stmt.raw_query();
|
||||
rows.next()?.map(|row| row.get(0)).transpose()
|
||||
}
|
||||
|
||||
/// Executes a query and returns the affected rows
|
||||
pub fn execute(
|
||||
self,
|
||||
conn: &PooledResource<SqliteConnectionManager>,
|
||||
) -> rusqlite::Result<usize> {
|
||||
self.get_stmt(conn)?.raw_execute()
|
||||
}
|
||||
|
||||
/// Runs the query and returns the first row or None
|
||||
pub fn fetch_one(
|
||||
self,
|
||||
conn: &PooledResource<SqliteConnectionManager>,
|
||||
) -> rusqlite::Result<Option<Vec<Column>>> {
|
||||
let mut stmt = self.get_stmt(conn)?;
|
||||
let columns = stmt.column_count();
|
||||
let mut rows = stmt.raw_query();
|
||||
rows.next()?
|
||||
.map(|row| {
|
||||
(0..columns)
|
||||
.map(|i| row.get(i))
|
||||
.collect::<Result<Vec<_>, _>>()
|
||||
})
|
||||
.transpose()
|
||||
}
|
||||
|
||||
/// Runs the query and returns the first row or None
|
||||
pub fn fetch_all(
|
||||
self,
|
||||
conn: &PooledResource<SqliteConnectionManager>,
|
||||
) -> rusqlite::Result<Vec<Vec<Column>>> {
|
||||
let mut stmt = self.get_stmt(conn)?;
|
||||
let columns = stmt.column_count();
|
||||
let mut rows = stmt.raw_query();
|
||||
let mut results = vec![];
|
||||
|
||||
while let Some(row) = rows.next()? {
|
||||
results.push(
|
||||
(0..columns)
|
||||
.map(|i| row.get(i))
|
||||
.collect::<Result<Vec<_>, _>>()?,
|
||||
);
|
||||
}
|
||||
|
||||
Ok(results)
|
||||
}
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
//! SQLite Wallet Error
|
||||
|
||||
use thiserror::Error;
|
||||
|
||||
/// SQLite Wallet Error
|
||||
#[derive(Debug, Error)]
|
||||
pub enum Error {
|
||||
/// SQLX Error
|
||||
#[error(transparent)]
|
||||
Sqlite(#[from] rusqlite::Error),
|
||||
/// Pool error
|
||||
#[error(transparent)]
|
||||
Pool(#[from] crate::pool::Error<rusqlite::Error>),
|
||||
|
||||
/// Missing columns
|
||||
#[error("Not enough elements: expected {0}, got {1}")]
|
||||
MissingColumn(usize, usize),
|
||||
|
||||
/// Invalid db type
|
||||
#[error("Invalid type from db, expected {0} got {1}")]
|
||||
InvalidType(String, String),
|
||||
|
||||
/// Invalid data conversion in column
|
||||
#[error("Error converting {0} to {1}")]
|
||||
InvalidConversion(String, String),
|
||||
|
||||
/// Serde Error
|
||||
#[error(transparent)]
|
||||
Serde(#[from] serde_json::Error),
|
||||
/// CDK Error
|
||||
#[error(transparent)]
|
||||
CDK(#[from] cdk_common::Error),
|
||||
/// NUT00 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT00(#[from] cdk_common::nuts::nut00::Error),
|
||||
/// NUT01 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT01(#[from] cdk_common::nuts::nut01::Error),
|
||||
/// NUT02 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT02(#[from] cdk_common::nuts::nut02::Error),
|
||||
/// NUT04 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT04(#[from] cdk_common::nuts::nut04::Error),
|
||||
/// NUT05 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT05(#[from] cdk_common::nuts::nut05::Error),
|
||||
/// NUT07 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT07(#[from] cdk_common::nuts::nut07::Error),
|
||||
/// NUT23 Error
|
||||
#[error(transparent)]
|
||||
CDKNUT23(#[from] cdk_common::nuts::nut23::Error),
|
||||
/// Secret Error
|
||||
#[error(transparent)]
|
||||
CDKSECRET(#[from] cdk_common::secret::Error),
|
||||
/// Mint Url
|
||||
#[error(transparent)]
|
||||
MintUrl(#[from] cdk_common::mint_url::Error),
|
||||
/// BIP32 Error
|
||||
#[error(transparent)]
|
||||
BIP32(#[from] bitcoin::bip32::Error),
|
||||
/// Could Not Initialize Database
|
||||
#[error("Could not initialize database")]
|
||||
CouldNotInitialize,
|
||||
/// Invalid Database Path
|
||||
#[error("Invalid database path")]
|
||||
InvalidDbPath,
|
||||
}
|
||||
|
||||
impl From<Error> for cdk_common::database::Error {
|
||||
fn from(e: Error) -> Self {
|
||||
Self::Database(Box::new(e))
|
||||
}
|
||||
}
|
||||
@@ -7,8 +7,10 @@ use super::WalletSqliteDatabase;
|
||||
/// Creates a new in-memory [`WalletSqliteDatabase`] instance
|
||||
pub async fn empty() -> Result<WalletSqliteDatabase, Error> {
|
||||
#[cfg(not(feature = "sqlcipher"))]
|
||||
let db = WalletSqliteDatabase::new(":memory:").await?;
|
||||
let path = ":memory:";
|
||||
|
||||
#[cfg(feature = "sqlcipher")]
|
||||
let db = WalletSqliteDatabase::new(":memory:", "memory".to_owned()).await?;
|
||||
Ok(db)
|
||||
let path = (":memory:", "memory");
|
||||
|
||||
WalletSqliteDatabase::new(path).await
|
||||
}
|
||||
|
||||
@@ -1,21 +0,0 @@
|
||||
// @generated
|
||||
// Auto-generated by build.rs
|
||||
pub static MIGRATIONS: &[(&str, &str)] = &[
|
||||
("20240612132920_init.sql", include_str!(r#"./migrations/20240612132920_init.sql"#)),
|
||||
("20240618200350_quote_state.sql", include_str!(r#"./migrations/20240618200350_quote_state.sql"#)),
|
||||
("20240626091921_nut04_state.sql", include_str!(r#"./migrations/20240626091921_nut04_state.sql"#)),
|
||||
("20240710144711_input_fee.sql", include_str!(r#"./migrations/20240710144711_input_fee.sql"#)),
|
||||
("20240810214105_mint_icon_url.sql", include_str!(r#"./migrations/20240810214105_mint_icon_url.sql"#)),
|
||||
("20240810233905_update_mint_url.sql", include_str!(r#"./migrations/20240810233905_update_mint_url.sql"#)),
|
||||
("20240902151515_icon_url.sql", include_str!(r#"./migrations/20240902151515_icon_url.sql"#)),
|
||||
("20240902210905_mint_time.sql", include_str!(r#"./migrations/20240902210905_mint_time.sql"#)),
|
||||
("20241011125207_mint_urls.sql", include_str!(r#"./migrations/20241011125207_mint_urls.sql"#)),
|
||||
("20241108092756_wallet_mint_quote_secretkey.sql", include_str!(r#"./migrations/20241108092756_wallet_mint_quote_secretkey.sql"#)),
|
||||
("20250214135017_mint_tos.sql", include_str!(r#"./migrations/20250214135017_mint_tos.sql"#)),
|
||||
("20250310111513_drop_nostr_last_checked.sql", include_str!(r#"./migrations/20250310111513_drop_nostr_last_checked.sql"#)),
|
||||
("20250314082116_allow_pending_spent.sql", include_str!(r#"./migrations/20250314082116_allow_pending_spent.sql"#)),
|
||||
("20250323152040_wallet_dleq_proofs.sql", include_str!(r#"./migrations/20250323152040_wallet_dleq_proofs.sql"#)),
|
||||
("20250401120000_add_transactions_table.sql", include_str!(r#"./migrations/20250401120000_add_transactions_table.sql"#)),
|
||||
("20250616144830_add_keyset_expiry.sql", include_str!(r#"./migrations/20250616144830_add_keyset_expiry.sql"#)),
|
||||
("20250707093445_bolt12.sql", include_str!(r#"./migrations/20250707093445_bolt12.sql"#)),
|
||||
];
|
||||
@@ -1,81 +0,0 @@
|
||||
-- Mints
|
||||
CREATE TABLE IF NOT EXISTS mint (
|
||||
mint_url TEXT PRIMARY KEY,
|
||||
name TEXT,
|
||||
pubkey BLOB,
|
||||
version TEXT,
|
||||
description TEXT,
|
||||
description_long TEXT,
|
||||
contact TEXT,
|
||||
nuts TEXT,
|
||||
motd TEXT
|
||||
);
|
||||
|
||||
|
||||
CREATE TABLE IF NOT EXISTS keyset (
|
||||
id TEXT PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
unit TEXT NOT NULL,
|
||||
active BOOL NOT NULL,
|
||||
counter INTEGER NOT NULL DEFAULT 0,
|
||||
FOREIGN KEY(mint_url) REFERENCES mint(mint_url) ON UPDATE CASCADE ON DELETE CASCADE
|
||||
);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS mint_quote (
|
||||
id TEXT PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
unit TEXT NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
paid BOOL NOT NULL DEFAULT FALSE,
|
||||
expiry INTEGER NOT NULL
|
||||
);
|
||||
|
||||
|
||||
CREATE INDEX IF NOT EXISTS paid_index ON mint_quote(paid);
|
||||
CREATE INDEX IF NOT EXISTS request_index ON mint_quote(request);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS melt_quote (
|
||||
id TEXT PRIMARY KEY,
|
||||
unit TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
fee_reserve INTEGER NOT NULL,
|
||||
paid BOOL NOT NULL DEFAULT FALSE,
|
||||
expiry INTEGER NOT NULL
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS paid_index ON melt_quote(paid);
|
||||
CREATE INDEX IF NOT EXISTS request_index ON melt_quote(request);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS key (
|
||||
id TEXT PRIMARY KEY,
|
||||
keys TEXT NOT NULL
|
||||
);
|
||||
|
||||
|
||||
-- Proof Table
|
||||
CREATE TABLE IF NOT EXISTS proof (
|
||||
y BLOB PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
state TEXT CHECK ( state IN ('SPENT', 'UNSPENT', 'PENDING', 'RESERVED' ) ) NOT NULL,
|
||||
spending_condition TEXT,
|
||||
unit TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS secret_index ON proof(secret);
|
||||
CREATE INDEX IF NOT EXISTS state_index ON proof(state);
|
||||
CREATE INDEX IF NOT EXISTS spending_condition_index ON proof(spending_condition);
|
||||
CREATE INDEX IF NOT EXISTS unit_index ON proof(unit);
|
||||
CREATE INDEX IF NOT EXISTS amount_index ON proof(amount);
|
||||
CREATE INDEX IF NOT EXISTS mint_url_index ON proof(mint_url);
|
||||
|
||||
CREATE TABLE IF NOT EXISTS nostr_last_checked (
|
||||
key BLOB PRIMARY KEY,
|
||||
last_check INTEGER NOT NULL
|
||||
);
|
||||
@@ -1,5 +0,0 @@
|
||||
ALTER TABLE melt_quote ADD state TEXT CHECK ( state IN ('UNPAID', 'PENDING', 'PAID' ) ) NOT NULL DEFAULT 'UNPAID';
|
||||
ALTER TABLE melt_quote ADD payment_preimage TEXT;
|
||||
ALTER TABLE melt_quote DROP COLUMN paid;
|
||||
CREATE INDEX IF NOT EXISTS melt_quote_state_index ON melt_quote(state);
|
||||
DROP INDEX IF EXISTS paid_index;
|
||||
@@ -1,3 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD state TEXT CHECK ( state IN ('UNPAID', 'PENDING', 'PAID', 'ISSUED' ) ) NOT NULL DEFAULT 'UNPAID';
|
||||
ALTER TABLE mint_quote DROP COLUMN paid;
|
||||
CREATE INDEX IF NOT EXISTS mint_quote_state_index ON mint_quote(state);
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE keyset ADD input_fee_ppk INTEGER;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint ADD mint_icon_url TEXT;
|
||||
@@ -1,21 +0,0 @@
|
||||
-- Delete duplicates from `mint`
|
||||
DELETE FROM `mint`
|
||||
WHERE `mint_url` IN (
|
||||
SELECT `mint_url`
|
||||
FROM (
|
||||
SELECT RTRIM(`mint_url`, '/') AS trimmed_url, MIN(rowid) AS keep_id
|
||||
FROM `mint`
|
||||
GROUP BY trimmed_url
|
||||
HAVING COUNT(*) > 1
|
||||
)
|
||||
)
|
||||
AND rowid NOT IN (
|
||||
SELECT MIN(rowid)
|
||||
FROM `mint`
|
||||
GROUP BY RTRIM(`mint_url`, '/')
|
||||
);
|
||||
|
||||
UPDATE `mint` SET `mint_url` = RTRIM(`mint_url`, '/');
|
||||
UPDATE `keyset` SET `mint_url` = RTRIM(`mint_url`, '/');
|
||||
UPDATE `mint_quote` SET `mint_url` = RTRIM(`mint_url`, '/');
|
||||
UPDATE `proof` SET `mint_url` = RTRIM(`mint_url`, '/');
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint RENAME COLUMN mint_icon_url TO icon_url;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint ADD mint_time INTEGER;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint ADD urls TEXT;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD secret_key TEXT;
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE mint ADD tos_url TEXT;
|
||||
@@ -1 +0,0 @@
|
||||
DROP TABLE IF EXISTS nostr_last_checked;
|
||||
@@ -1,31 +0,0 @@
|
||||
-- Create a new table with the updated CHECK constraint
|
||||
CREATE TABLE IF NOT EXISTS proof_new (
|
||||
y BLOB PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
state TEXT CHECK ( state IN ('SPENT', 'UNSPENT', 'PENDING', 'RESERVED', 'PENDING_SPENT' ) ) NOT NULL,
|
||||
spending_condition TEXT,
|
||||
unit TEXT NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
keyset_id TEXT NOT NULL,
|
||||
secret TEXT NOT NULL,
|
||||
c BLOB NOT NULL,
|
||||
witness TEXT
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS secret_index ON proof_new(secret);
|
||||
CREATE INDEX IF NOT EXISTS state_index ON proof_new(state);
|
||||
CREATE INDEX IF NOT EXISTS spending_condition_index ON proof_new(spending_condition);
|
||||
CREATE INDEX IF NOT EXISTS unit_index ON proof_new(unit);
|
||||
CREATE INDEX IF NOT EXISTS amount_index ON proof_new(amount);
|
||||
CREATE INDEX IF NOT EXISTS mint_url_index ON proof_new(mint_url);
|
||||
|
||||
-- Copy data from old proof table to new proof table
|
||||
INSERT INTO proof_new (y, mint_url, state, spending_condition, unit, amount, keyset_id, secret, c, witness)
|
||||
SELECT y, mint_url, state, spending_condition, unit, amount, keyset_id, secret, c, witness
|
||||
FROM proof;
|
||||
|
||||
-- Drop the old proof table
|
||||
DROP TABLE proof;
|
||||
|
||||
-- Rename the new proof table to proof
|
||||
ALTER TABLE proof_new RENAME TO proof;
|
||||
@@ -1,4 +0,0 @@
|
||||
-- Migration to add DLEQ proof storage to the proof table
|
||||
ALTER TABLE proof ADD COLUMN dleq_e BLOB;
|
||||
ALTER TABLE proof ADD COLUMN dleq_s BLOB;
|
||||
ALTER TABLE proof ADD COLUMN dleq_r BLOB;
|
||||
@@ -1,18 +0,0 @@
|
||||
-- Migration to add transactions table
|
||||
CREATE TABLE IF NOT EXISTS transactions (
|
||||
id BLOB PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
direction TEXT CHECK (direction IN ('Incoming', 'Outgoing')) NOT NULL,
|
||||
amount INTEGER NOT NULL,
|
||||
fee INTEGER NOT NULL,
|
||||
unit TEXT NOT NULL,
|
||||
ys BLOB NOT NULL,
|
||||
timestamp INTEGER NOT NULL,
|
||||
memo TEXT,
|
||||
metadata TEXT
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS mint_url_index ON transactions(mint_url);
|
||||
CREATE INDEX IF NOT EXISTS direction_index ON transactions(direction);
|
||||
CREATE INDEX IF NOT EXISTS unit_index ON transactions(unit);
|
||||
CREATE INDEX IF NOT EXISTS timestamp_index ON transactions(timestamp);
|
||||
@@ -1 +0,0 @@
|
||||
ALTER TABLE keyset ADD COLUMN final_expiry INTEGER DEFAULT NULL;
|
||||
@@ -1,58 +0,0 @@
|
||||
ALTER TABLE mint_quote ADD COLUMN amount_paid INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE mint_quote ADD COLUMN amount_minted INTEGER NOT NULL DEFAULT 0;
|
||||
ALTER TABLE mint_quote ADD COLUMN payment_method TEXT NOT NULL DEFAULT 'BOLT11';
|
||||
|
||||
-- Remove NOT NULL constraint from amount column
|
||||
PRAGMA foreign_keys=off;
|
||||
CREATE TABLE mint_quote_new (
|
||||
id TEXT PRIMARY KEY,
|
||||
mint_url TEXT NOT NULL,
|
||||
payment_method TEXT NOT NULL DEFAULT 'bolt11',
|
||||
amount INTEGER,
|
||||
unit TEXT NOT NULL,
|
||||
request TEXT NOT NULL,
|
||||
state TEXT NOT NULL,
|
||||
expiry INTEGER NOT NULL,
|
||||
amount_paid INTEGER NOT NULL DEFAULT 0,
|
||||
amount_issued INTEGER NOT NULL DEFAULT 0,
|
||||
secret_key TEXT
|
||||
);
|
||||
|
||||
-- Explicitly specify columns for proper mapping
|
||||
INSERT INTO mint_quote_new (
|
||||
id,
|
||||
mint_url,
|
||||
payment_method,
|
||||
amount,
|
||||
unit,
|
||||
request,
|
||||
state,
|
||||
expiry,
|
||||
amount_paid,
|
||||
amount_issued,
|
||||
secret_key
|
||||
)
|
||||
SELECT
|
||||
id,
|
||||
mint_url,
|
||||
'bolt11', -- Default value for the new payment_method column
|
||||
amount,
|
||||
unit,
|
||||
request,
|
||||
state,
|
||||
expiry,
|
||||
0, -- Default value for amount_paid
|
||||
0, -- Default value for amount_minted
|
||||
secret_key
|
||||
FROM mint_quote;
|
||||
|
||||
DROP TABLE mint_quote;
|
||||
ALTER TABLE mint_quote_new RENAME TO mint_quote;
|
||||
PRAGMA foreign_keys=on;
|
||||
|
||||
|
||||
-- Set amount_paid equal to amount for quotes with PAID or ISSUED state
|
||||
UPDATE mint_quote SET amount_paid = amount WHERE state = 'PAID' OR state = 'ISSUED';
|
||||
|
||||
-- Set amount_issued equal to amount for quotes with ISSUED state
|
||||
UPDATE mint_quote SET amount_issued = amount WHERE state = 'ISSUED';
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user