use std::fmt::Write as _;
use std::io::{Read as _, Write as _};
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::{Duration, Instant};
mod common;
use chdb_rust::connection::Connection;
use chdb_rust::error::Error;
use chdb_rust::format::OutputFormat;
use chdb_rust::session::SessionBuilder;
const CASE_ENV: &str = "CHDB_RUNTIME_CASE";
const CASE_LIMIT: Duration = Duration::from_secs(60);
struct Case {
name: &'static str,
expect: &'static str,
run: fn(),
}
fn cases() -> Vec<Case> {
let mut cases = vec![
Case {
name: "locale_formatting",
expect: "1.23 million|117.74 MiB|-1.5|1234.5678\n",
run: locale_formatting,
},
Case {
name: "wide_character_output",
expect: "日本語テキスト|3|éfac|Ελλ\n",
run: wide_character_output,
},
Case {
name: "non_ascii_path",
expect: "created|3|6\n",
run: non_ascii_path,
},
Case {
name: "regexp_functions",
expect: "1|a·b·c|1,2,3\n",
run: regexp_functions,
},
Case {
name: "caught_engine_errors",
expect:
"syntax=Code: 62|divide=Code: 153|mismatch=Code: 43|rethrown=Code: 62|alive=1\n",
run: caught_engine_errors,
},
Case {
name: "session_disk_roundtrip",
expect: "rows=50000|sum=1249975000|parts>=1\n",
run: session_disk_roundtrip,
},
Case {
name: "large_result_buffer",
expect: "bytes=1288890|lines=200000|last=199999\n",
run: large_result_buffer,
},
Case {
name: "concurrent_connections",
expect: "0=1000|1=1000|2=1000|3=1000\n",
run: concurrent_connections,
},
Case {
name: "exit_after_close",
expect: "first=1|second=2\n",
run: exit_after_close,
},
Case {
name: "signal_handlers_before_connect",
expect: "ok\n",
run: signal_handlers_before_connect,
},
Case {
name: "disabling_after_connect_takes_effect",
expect: "ok\n",
run: disabling_after_connect_takes_effect,
},
Case {
name: "reset_signal_handlers_restores_default",
expect: "ok\n",
run: reset_signal_handlers_restores_default,
},
Case {
name: "shutdown_refuses_while_a_connection_is_open",
expect: "refused|ok\n",
run: shutdown_refuses_while_a_connection_is_open,
},
Case {
name: "connect_after_shutdown_is_refused",
expect: "shutdown|refused|idempotent\n",
run: connect_after_shutdown_is_refused,
},
Case {
name: "shutdown_after_mergetree_merges",
expect: "rows=200000|closed|shutdown\n",
run: shutdown_after_mergetree_merges,
},
];
#[cfg(feature = "arrow")]
cases.push(Case {
name: "arrow_release_callback",
expect: "inserted=4|sum=100|released\n",
run: arrow_release_callback,
});
#[cfg(feature = "static")]
cases.push(Case {
name: "host_backtrace_and_panic",
expect: "backtrace=ok|panic=ok\n",
run: host_backtrace_and_panic,
});
cases
}
fn scalar_row(sql: &str) -> String {
let conn = Connection::open_in_memory().expect("connect");
let result = conn.query(sql, OutputFormat::TabSeparated).expect(sql);
let text = result.data_utf8().expect("utf-8");
text.trim_end_matches('\n').replace('\t', "|")
}
fn locale_formatting() {
println!(
"{}",
scalar_row(
"SELECT formatReadableQuantity(1234567), \
formatReadableSize(123456789), \
toString(-1.5), \
toString(toDecimal64(1234.5678, 4))"
)
);
}
fn wide_character_output() {
println!(
"{}",
scalar_row(concat!(
"SELECT '日本語テキスト', ",
"lengthUTF8('🦀🦀🦀'), ",
"reverseUTF8('café'), ",
"substringUTF8('Ελληνικά', 1, 3)"
))
);
}
fn non_ascii_path() {
let dir = scratch_dir("数据-café-Ω");
let session = SessionBuilder::new()
.with_data_path(&dir)
.with_auto_cleanup(true)
.build()
.expect("session on a non-ASCII path");
session
.execute("CREATE DATABASE IF NOT EXISTS d", None)
.expect("create database");
session
.execute(
"CREATE TABLE IF NOT EXISTS d.t (x UInt32) ENGINE = MergeTree ORDER BY x",
None,
)
.expect("create table");
session
.execute("INSERT INTO d.t VALUES (1), (2), (3)", None)
.expect("insert");
let created = if dir.exists() { "created" } else { "missing" };
let counted = session
.execute("SELECT count(), sum(x) FROM d.t", None)
.expect("read back")
.data_utf8()
.expect("utf-8")
.trim_end_matches('\n')
.replace('\t', "|");
println!("{created}|{counted}");
}
fn regexp_functions() {
println!(
"{}",
scalar_row(concat!(
r"SELECT match('café-2026', '^caf.-\\d{4}$'), ",
r"replaceRegexpAll('aXbXc', 'X', '·'), ",
r"arrayStringConcat(extractAll('日本1語2テキスト3', '\\d'), ',')"
))
);
}
fn error_code(error: &Error) -> String {
let text = error.to_string();
match text.find('.') {
Some(end) if text.starts_with("Code: ") => text[..end].to_string(),
_ => format!("unexpected error shape: {text}"),
}
}
fn wrap_engine_error(conn: &Connection) -> Result<(), Error> {
conn.query("SELECT FROM WHERE", OutputFormat::TabSeparated)
.map(|_| ())
.map_err(|e| Error::InvalidData(e.to_string()))
}
fn caught_engine_errors() {
let conn = Connection::open_in_memory().expect("connect");
let mut line = String::new();
for (label, sql) in [
("syntax", "SELECT FROM WHERE"),
("divide", "SELECT intDiv(1, 0)"),
("mismatch", "SELECT [1, 2, 3] + 1"),
] {
let error = conn
.query(sql, OutputFormat::TabSeparated)
.expect_err(sql)
.to_string();
let code = error_code(&Error::QueryError(error));
write!(line, "{label}={code}|").expect("write");
}
let rethrown = wrap_engine_error(&conn).expect_err("rethrow");
let inner = match &rethrown {
Error::InvalidData(text) => error_code(&Error::QueryError(text.clone())),
other => format!("unexpected: {other}"),
};
write!(line, "rethrown={inner}|").expect("write");
let alive = scalar_row_on(&conn, "SELECT 1");
println!("{line}alive={alive}");
}
fn scalar_row_on(conn: &Connection, sql: &str) -> String {
conn.query(sql, OutputFormat::TabSeparated)
.expect(sql)
.data_utf8()
.expect("utf-8")
.trim_end_matches('\n')
.replace('\t', "|")
}
fn session_disk_roundtrip() {
let dir = scratch_dir("disk-roundtrip");
let session = SessionBuilder::new()
.with_data_path(&dir)
.with_auto_cleanup(true)
.build()
.expect("session");
session
.execute("CREATE DATABASE IF NOT EXISTS d", None)
.expect("create database");
session
.execute(
"CREATE TABLE d.t (x UInt32, s String) ENGINE = MergeTree ORDER BY x",
None,
)
.expect("create table");
session
.execute(
"INSERT INTO d.t SELECT number, toString(number) FROM numbers(50000)",
None,
)
.expect("insert");
let counted = session
.execute("SELECT count(), sum(x) FROM d.t", None)
.expect("aggregate")
.data_utf8()
.expect("utf-8")
.trim_end_matches('\n')
.replace('\t', "|");
let parts: u64 = session
.execute(
"SELECT count() FROM system.parts WHERE database = 'd' AND table = 't' AND active",
None,
)
.expect("system.parts")
.data_utf8()
.expect("utf-8")
.trim()
.parse()
.expect("part count");
let (rows, sum) = counted.split_once('|').expect("two columns");
println!(
"rows={rows}|sum={sum}|parts{}",
if parts >= 1 { ">=1" } else { "=0" }
);
}
fn large_result_buffer() {
let conn = Connection::open_in_memory().expect("connect");
let result = conn
.query("SELECT number FROM numbers(200000)", OutputFormat::CSV)
.expect("query");
let bytes = result.data_ref().len();
let text = result.data_utf8().expect("utf-8");
let lines = text.lines().count();
let last = text.lines().next_back().unwrap_or_default().to_string();
drop(result);
drop(conn);
println!("bytes={bytes}|lines={lines}|last={last}");
}
fn concurrent_connections() {
let handles: Vec<_> = (0..4)
.map(|id| {
std::thread::spawn(move || {
let conn = Connection::open_in_memory().expect("connect");
let counted = scalar_row_on(&conn, "SELECT count() FROM numbers(1000)");
format!("{id}={counted}")
})
})
.collect();
let mut answers: Vec<String> = handles
.into_iter()
.map(|handle| handle.join().expect("thread"))
.collect();
answers.sort();
println!("{}", answers.join("|"));
}
fn exit_after_close() {
let mut line = String::new();
for (label, sql) in [("first", "SELECT 1"), ("second", "SELECT 2")] {
let conn = Connection::open_in_memory().expect("connect");
let value = scalar_row_on(&conn, sql);
drop(conn);
if !line.is_empty() {
line.push('|');
}
write!(line, "{label}={value}").expect("write");
}
println!("{line}");
}
#[cfg(feature = "arrow")]
fn arrow_release_callback() {
use chdb_rust::arrow::array::{Int32Array, RecordBatch};
use chdb_rust::arrow::datatypes::{DataType, Field, Schema};
use chdb_rust::InsertOptions;
use std::sync::Arc;
let dir = scratch_dir("arrow-release");
let session = SessionBuilder::new()
.with_data_path(&dir)
.with_auto_cleanup(true)
.build()
.expect("session");
session
.execute("CREATE DATABASE IF NOT EXISTS d", None)
.expect("create database");
session
.execute(
"CREATE TABLE d.t (x Int32) ENGINE = MergeTree ORDER BY x",
None,
)
.expect("create table");
let schema = Arc::new(Schema::new(vec![Field::new("x", DataType::Int32, false)]));
let batch = RecordBatch::try_new(
schema,
vec![Arc::new(Int32Array::from(vec![10, 20, 30, 40]))],
)
.expect("batch");
let rows = batch.num_rows();
chdb_rust::insert_record_batch(
session.connection(),
"d.t",
"release_probe",
batch,
InsertOptions::default(),
)
.expect("insert");
let sum = scalar_row_on(session.connection(), "SELECT sum(x) FROM d.t");
println!("inserted={rows}|sum={sum}|released");
}
fn signal_handlers_before_connect() {
chdb_rust::runtime::signal_handlers(false);
let conn = Connection::open_in_memory().expect("open");
let result = conn
.query("SELECT 1", OutputFormat::TabSeparated)
.expect("query");
assert_eq!(result.data_utf8_lossy().trim(), "1");
println!("ok");
}
#[cfg(feature = "static")]
fn host_backtrace_and_panic() {
chdb_rust::runtime::signal_handlers(false);
let conn = Connection::open_in_memory().expect("open");
assert!(conn
.query("SELECT * FROM chdb_rust_missing_table", OutputFormat::CSV)
.is_err());
let trace = std::backtrace::Backtrace::force_capture();
assert_eq!(trace.status(), std::backtrace::BacktraceStatus::Captured);
assert!(!trace.to_string().trim().is_empty());
print!("backtrace=ok|");
std::panic::set_hook(Box::new(|_| {}));
assert!(std::panic::catch_unwind(|| panic!("expected panic")).is_err());
drop(conn);
println!("panic=ok");
}
fn signal_disposition(sig: libc::c_int) -> libc::sighandler_t {
let mut old: libc::sigaction = unsafe { std::mem::zeroed() };
let rc = unsafe { libc::sigaction(sig, std::ptr::null(), &mut old) };
assert_eq!(
rc,
0,
"sigaction query failed: {}",
std::io::Error::last_os_error()
);
old.sa_sigaction
}
fn disabling_after_connect_takes_effect() {
let conn = Connection::open_in_memory().expect("open");
let _ = scalar_row_on(&conn, "SELECT 1");
chdb_rust::runtime::signal_handlers(false);
assert_eq!(
signal_disposition(libc::SIGSEGV),
libc::SIG_DFL,
"disabling should reset the handler chDB just installed"
);
let result = scalar_row_on(&conn, "SELECT 2");
assert_eq!(result, "2");
assert_eq!(
signal_disposition(libc::SIGSEGV),
libc::SIG_DFL,
"disabling should stay in effect across the next query"
);
println!("ok");
}
fn reset_signal_handlers_restores_default() {
let conn = Connection::open_in_memory().expect("open");
let _ = scalar_row_on(&conn, "SELECT 1");
assert_ne!(
signal_disposition(libc::SIGSEGV),
libc::SIG_DFL,
"connect should install chDB's deadly-signal handlers"
);
chdb_rust::runtime::reset_signal_handlers();
assert_eq!(
signal_disposition(libc::SIGSEGV),
libc::SIG_DFL,
"reset should restore SIG_DFL"
);
let result = scalar_row_on(&conn, "SELECT 2");
assert_eq!(result, "2");
assert_eq!(
signal_disposition(libc::SIGSEGV),
libc::SIG_DFL,
"a subsequent query on this connection must not reinstall handlers"
);
println!("ok");
}
fn shutdown_refuses_while_a_connection_is_open() {
let conn = Connection::open_in_memory().expect("open");
match chdb_rust::runtime::shutdown() {
Err(Error::ConnectionsStillOpen { count: 1 }) => print!("refused|"),
other => panic!("expected ConnectionsStillOpen {{ count: 1 }}, got {other:?}"),
}
drop(conn);
chdb_rust::runtime::shutdown().expect("shutdown with nothing open");
println!("ok");
}
fn connect_after_shutdown_is_refused() {
let conn = Connection::open_in_memory().expect("open");
drop(conn);
chdb_rust::runtime::shutdown().expect("shutdown");
print!("shutdown|");
match Connection::open_in_memory() {
Err(Error::EngineShutDown) => print!("refused|"),
other => panic!("expected EngineShutDown, got {other:?}"),
}
chdb_rust::runtime::shutdown().expect("second shutdown is a no-op");
println!("idempotent");
}
fn shutdown_after_mergetree_merges() {
let dir = scratch_dir("mergetree-shutdown");
let session = SessionBuilder::new()
.with_data_path(&dir)
.with_auto_cleanup(true)
.build()
.expect("session");
session
.execute("CREATE DATABASE IF NOT EXISTS d", None)
.expect("create database");
session
.execute(
"CREATE TABLE d.t (x UInt64, s String) ENGINE = MergeTree ORDER BY x",
None,
)
.expect("create table");
for part in 0..20 {
session
.execute(
&format!(
"INSERT INTO d.t SELECT number + {}, repeat('x', 100) FROM numbers(10000)",
part * 10000
),
None,
)
.expect("insert");
}
let rows = session
.execute("SELECT count() FROM d.t", None)
.expect("count")
.data_utf8()
.expect("utf-8")
.trim_end()
.to_owned();
print!("rows={rows}|");
drop(session);
print!("closed|");
chdb_rust::runtime::shutdown().expect("shutdown after MergeTree merges");
println!("shutdown");
}
fn scratch_dir(suffix: &str) -> PathBuf {
let dir = std::env::temp_dir().join(format!("chdb-runtime-{}-{suffix}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
dir
}
fn main() {
match std::env::var(CASE_ENV) {
Ok(name) => run_one(&name),
Err(_) => run_all(),
}
}
fn run_one(name: &str) {
let cases = cases();
let case = cases
.iter()
.find(|case| case.name == name)
.unwrap_or_else(|| panic!("no case named {name}"));
(case.run)();
std::io::stdout().flush().expect("flush");
}
fn run_all() {
let filter = std::env::args().skip(1).find(|arg| !arg.starts_with('-'));
let exe = std::env::current_exe().expect("current_exe");
let cases = cases();
let selected: Vec<&Case> = cases
.iter()
.filter(|case| filter.as_deref().is_none_or(|f| case.name.contains(f)))
.collect();
println!("running {} runtime cases", selected.len());
let mut failures = Vec::new();
for case in &selected {
match run_child(&exe, case) {
Ok(elapsed) => println!(" {} ... ok ({} ms)", case.name, elapsed.as_millis()),
Err(reason) => {
println!(" {} ... FAILED", case.name);
failures.push((case.name, reason));
}
}
}
if failures.is_empty() {
println!("all {} runtime cases passed", selected.len());
return;
}
println!("\nfailures:");
for (name, reason) in &failures {
println!("\n---- {name} ----\n{reason}");
}
std::process::exit(1);
}
fn run_child(exe: &Path, case: &Case) -> Result<Duration, String> {
let mut command = common::command(exe);
command
.env(CASE_ENV, case.name)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::inherit());
let mut child = command.spawn().map_err(|e| format!("cannot spawn: {e}"))?;
let mut pipe = child.stdout.take().ok_or("stdout was not piped")?;
let reader = std::thread::spawn(move || {
let mut captured = Vec::new();
let _ = pipe.read_to_end(&mut captured);
captured
});
let started = Instant::now();
let status = loop {
match child.try_wait() {
Ok(Some(status)) => break status,
Ok(None) => {
if started.elapsed() >= CASE_LIMIT {
let _ = child.kill();
let _ = child.wait();
return Err(format!(
"still running after {} s, killed. A case that does not \
return is the failure this suite exists to catch.",
CASE_LIMIT.as_secs()
));
}
std::thread::sleep(Duration::from_millis(20));
}
Err(e) => return Err(format!("cannot wait: {e}")),
}
};
let elapsed = started.elapsed();
let captured = reader.join().map_err(|_| "the capture thread panicked")?;
let actual = String::from_utf8_lossy(&captured);
if !status.success() {
return Err(format!(
"exited with {status}\n stdout was: {actual:?}\n expected: {:?}",
case.expect
));
}
if actual != case.expect {
return Err(format!(
"stdout does not match\n expected: {:?}\n actual: {:?}",
case.expect, actual
));
}
Ok(elapsed)
}