use std::path::Path;
use crate::bindings;
use crate::connection::Connection;
use crate::error::{Error, Result};
use crate::query_result::QueryResult;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum QueryClass {
ReadOnly,
Mutating,
MutatingGlobal,
Control,
Unknown,
}
impl QueryClass {
fn from_abi(value: u32) -> Self {
match value {
bindings::chdb_query_class_CHDB_QUERY_READ_ONLY => Self::ReadOnly,
bindings::chdb_query_class_CHDB_QUERY_MUTATING => Self::Mutating,
bindings::chdb_query_class_CHDB_QUERY_MUTATING_GLOBAL => Self::MutatingGlobal,
bindings::chdb_query_class_CHDB_QUERY_CONTROL => Self::Control,
_ => Self::Unknown,
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::ReadOnly => "READ_ONLY",
Self::Mutating => "MUTATING",
Self::MutatingGlobal => "MUTATING_GLOBAL",
Self::Control => "CONTROL",
Self::Unknown => "UNKNOWN",
}
}
}
impl std::fmt::Display for QueryClass {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub struct QueryAnalysis {
pub class: QueryClass,
pub statement_count: u32,
pub has_secrets: bool,
pub writes_only_target_database: bool,
pub changes_database_lifecycle: bool,
}
impl QueryAnalysis {
pub fn new(class: QueryClass, statement_count: u32) -> Self {
Self {
class,
statement_count,
has_secrets: false,
writes_only_target_database: false,
changes_database_lifecycle: false,
}
}
pub fn with_secrets(mut self, yes: bool) -> Self {
self.has_secrets = yes;
self
}
pub fn with_writes_only_target_database(mut self, yes: bool) -> Self {
self.writes_only_target_database = yes;
self
}
pub fn with_changes_database_lifecycle(mut self, yes: bool) -> Self {
self.changes_database_lifecycle = yes;
self
}
}
impl Connection {
pub fn backup_database(&self, database: &str, file_path: &Path) -> Result<()> {
let path = absolute_str(file_path, "backup")?;
let result_ptr = unsafe {
bindings::chdb_backup_database_n(
self.raw(),
database.as_ptr().cast(),
database.len(),
path.as_ptr().cast(),
path.len(),
std::ptr::null(),
0,
)
};
check(result_ptr)
}
pub fn restore_database(&self, database: &str, file_path: &Path) -> Result<()> {
let path = absolute_str(file_path, "restore")?;
let result_ptr = unsafe {
bindings::chdb_restore_database_n(
self.raw(),
database.as_ptr().cast(),
database.len(),
path.as_ptr().cast(),
path.len(),
)
};
check(result_ptr)
}
pub fn classify_query(
&self,
sql: &str,
target_database: Option<&str>,
) -> Result<QueryAnalysis> {
let mut analysis = bindings::chdb_query_analysis_v1 {
struct_size: std::mem::size_of::<bindings::chdb_query_analysis_v1>() as u32,
statement_count: 0,
flags: 0,
query_class: bindings::chdb_query_class_CHDB_QUERY_UNKNOWN,
};
let (target_ptr, target_len) = match target_database {
Some(database) => (database.as_ptr().cast(), database.len()),
None => (std::ptr::null(), 0),
};
let state = unsafe {
bindings::chdb_classify_query_n(
self.raw(),
sql.as_ptr().cast(),
sql.len(),
target_ptr,
target_len,
&mut analysis,
)
};
if state != bindings::chdb_state_CHDBSuccess {
return Err(Error::QueryError(
"the engine could not analyse the statement".to_string(),
));
}
let class = QueryClass::from_abi(analysis.query_class);
Ok(QueryAnalysis {
class,
statement_count: analysis.statement_count,
has_secrets: has_flag(
analysis.flags,
bindings::chdb_query_analysis_flag_CHDB_QUERY_HAS_SECRETS,
),
writes_only_target_database: has_flag(
analysis.flags,
bindings::chdb_query_analysis_flag_CHDB_QUERY_WRITES_ONLY_TARGET_DATABASE,
),
changes_database_lifecycle: has_flag(
analysis.flags,
bindings::chdb_query_analysis_flag_CHDB_QUERY_CHANGES_DATABASE_LIFECYCLE,
),
})
}
}
fn has_flag(flags: u32, flag: bindings::chdb_query_analysis_flag) -> bool {
flags & flag != 0
}
fn absolute_str<'a>(path: &'a Path, what: &str) -> Result<&'a str> {
if !path.is_absolute() {
return Err(Error::InvalidData(format!(
"{what} path must be absolute, got {}",
path.display()
)));
}
path.to_str().ok_or(Error::PathError)
}
fn check(result_ptr: *mut bindings::chdb_result) -> Result<()> {
if result_ptr.is_null() {
return Err(Error::NoResult);
}
QueryResult::new(result_ptr).check_error().map(|_| ())
}
#[cfg(test)]
mod test {
use super::*;
use crate::test_utils::tempdir;
fn connection(tmp: &std::path::Path, data: &str) -> Result<Connection> {
let data_dir = tmp.join(data);
let archives = tmp.join("archives");
std::fs::create_dir_all(&data_dir)?;
std::fs::create_dir_all(&archives)?;
let data = format!("--path={}", data_dir.to_str().expect("a UTF-8 path"));
let allowed = format!(
"--backups.allowed_path={}",
archives.to_str().expect("a UTF-8 path")
);
Connection::open(&[&data, &allowed])
}
#[test]
fn classification_sees_through_inline_data_and_unqualified_names() -> Result<()> {
let tmp = tempdir();
let conn = connection(tmp.path(), "data")?;
conn.query("CREATE DATABASE mem", crate::format::OutputFormat::CSV)?;
conn.query("USE mem", crate::format::OutputFormat::CSV)?;
let inline = conn.classify_query("INSERT INTO t VALUES ('a;b')", Some("mem"))?;
assert_eq!(inline.statement_count, 1);
assert_eq!(inline.class, QueryClass::Mutating);
assert!(inline.writes_only_target_database);
let elsewhere = conn.classify_query("INSERT INTO t VALUES (1)", Some("other"))?;
assert!(!elsewhere.writes_only_target_database);
let two = conn.classify_query("SELECT 1; SELECT 2", Some("mem"))?;
assert_eq!(two.statement_count, 2);
let nonsense = conn.classify_query("this is not sql", Some("mem"))?;
assert_eq!(nonsense.class, QueryClass::Unknown);
assert_eq!(nonsense.statement_count, 0);
assert!(!nonsense.has_secrets);
Ok(())
}
#[test]
fn a_backup_round_trips_through_an_archive() -> Result<()> {
let tmp = tempdir();
let archive = tmp.path().join("archives").join("mem.tar.gz");
{
let conn = connection(tmp.path(), "origin")?;
conn.query("CREATE DATABASE mem", crate::format::OutputFormat::CSV)?;
conn.query(
"CREATE TABLE mem.t (n UInt64) ENGINE = MergeTree ORDER BY n",
crate::format::OutputFormat::CSV,
)?;
conn.query(
"INSERT INTO mem.t VALUES (7)",
crate::format::OutputFormat::CSV,
)?;
conn.backup_database("mem", &archive)?;
assert!(archive.exists());
assert!(conn.backup_database("mem", &archive).is_err());
}
let conn = connection(tmp.path(), "recovered")?;
conn.restore_database("mem", &archive)?;
let rows = conn.query("SELECT n FROM mem.t", crate::format::OutputFormat::CSV)?;
assert_eq!(rows.data_utf8_lossy().trim(), "7");
Ok(())
}
#[test]
fn a_relative_archive_path_is_refused_before_the_engine_sees_it() -> Result<()> {
let tmp = tempdir();
let conn = connection(tmp.path(), "data")?;
let err = conn
.backup_database("mem", Path::new("relative.tar.gz"))
.expect_err("a relative backup path is refused");
assert!(err.to_string().contains("must be absolute"), "{err}");
Ok(())
}
}