use crate::btree::{BTreeStorage, engine};
use crate::error::{Error, Result};
use crate::graph::GraphEngine;
use crate::memory::bm25::Bm25Index;
use crate::pager::Pager;
use crate::sql::catalog::{
Catalog, ColumnDef, DataType, DefaultValue, ForeignKeyAction, IndexDef, TableDef,
TableForeignKey, TriggerDef, TriggerEvent, TriggerTiming,
};
use crate::sql::codec::{
decode_row, decode_row_shared, decode_row_shared_projected, decode_row_values_into_projected,
encode_row, encode_row_into,
};
use crate::sql::lexer::{Token, tokenize};
use crate::sql::parser::{
BinaryOp, JoinType, OnConflict, Statement, WhereCondition, WhereExpr, parse_tokens,
};
use crate::traits::{HashableValue, Row, Value, VectorIndexEngine, col_name_matches};
use crate::vector::{DistanceMetric, HnswIndex};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
#[derive(Debug, Clone, PartialEq)]
pub enum ResolvedWhereExpr {
Condition(WhereCondition),
And(Box<ResolvedWhereExpr>, Box<ResolvedWhereExpr>),
Or(Box<ResolvedWhereExpr>, Box<ResolvedWhereExpr>),
InList {
column: String,
values: Vec<Value>,
negated: bool,
},
Boolean(bool),
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TemporalRecord {
pub id: u64,
pub table_name: String,
pub row_id: u64,
pub valid_from: u64,
pub valid_to: u64,
pub payload: Vec<u8>,
}
#[derive(Default, Clone, Copy)]
pub struct FastIntHasher(u64);
impl std::hash::Hasher for FastIntHasher {
#[inline]
fn finish(&self) -> u64 {
self.0
}
#[inline]
fn write(&mut self, _bytes: &[u8]) {}
#[inline]
fn write_i64(&mut self, i: i64) {
let mut x = (i as u64) ^ 0x517cc1b727220a95;
x = (x ^ (x >> 30)).wrapping_mul(0xbf58476d1ce4e5b9);
x = (x ^ (x >> 27)).wrapping_mul(0x94d049bb133111eb);
self.0 = x ^ (x >> 31);
}
#[inline]
fn write_u64(&mut self, i: u64) {
self.write_i64(i as i64);
}
}
pub type FastIntBuildHasher = std::hash::BuildHasherDefault<FastIntHasher>;
#[derive(Clone, Debug)]
pub enum IntEntry {
One(usize),
Many(Vec<usize>),
}
#[derive(Clone, Copy, Debug)]
pub enum JoinOutputCol {
Left(usize),
Right(usize),
}
#[inline]
pub fn resolve_table_col_index(table_def: &TableDef, col: &str) -> Option<usize> {
if let Some((_, c)) = col.split_once('.') {
table_def.column_index(c)
} else {
table_def.column_index(col)
}
}
pub fn value_to_index_key(val: &Value) -> u64 {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
match val {
Value::Null => {
0u8.hash(&mut hasher);
}
Value::Integer(i) => {
1u8.hash(&mut hasher);
i.hash(&mut hasher);
}
Value::Real(f) => {
2u8.hash(&mut hasher);
f.to_bits().hash(&mut hasher);
}
Value::Text(s) => {
3u8.hash(&mut hasher);
s.hash(&mut hasher);
}
Value::Blob(b) => {
4u8.hash(&mut hasher);
b.hash(&mut hasher);
}
Value::Vector(v) => {
5u8.hash(&mut hasher);
for x in v {
x.to_bits().hash(&mut hasher);
}
}
}
let h = hasher.finish();
if h == 0 { 1 } else { h }
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IndexPostingEntry {
pub value: Value,
pub row_ids: Vec<u64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IndexBucket {
pub entries: Vec<IndexPostingEntry>,
}
impl IndexBucket {
pub fn new() -> Self {
Self {
entries: Vec::new(),
}
}
pub fn get_row_ids(&self, val: &Value) -> Option<&[u64]> {
self.entries
.iter()
.find(|e| &e.value == val)
.map(|e| e.row_ids.as_slice())
}
pub fn add_row_id(&mut self, val: Value, row_id: u64) {
if let Some(entry) = self.entries.iter_mut().find(|e| e.value == val) {
if !entry.row_ids.contains(&row_id) {
entry.row_ids.push(row_id);
}
} else {
self.entries.push(IndexPostingEntry {
value: val,
row_ids: vec![row_id],
});
}
}
pub fn remove_row_id(&mut self, val: &Value, row_id: u64) -> bool {
let mut changed = false;
if let Some(entry) = self.entries.iter_mut().find(|e| &e.value == val) {
let before = entry.row_ids.len();
entry.row_ids.retain(|&id| id != row_id);
changed = entry.row_ids.len() != before;
}
self.entries.retain(|e| !e.row_ids.is_empty());
changed
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
impl Default for IndexBucket {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VectorSnapshotRecord {
pub table_name: String,
pub snapshot: crate::vector::HnswSnapshot,
#[serde(default)]
pub table_fingerprint: Option<u32>,
}
fn extract_index_key_value<S: AsRef<str>>(row: &Row, cols: &[S]) -> Option<(Value, bool)> {
if cols.is_empty() {
return None;
}
if cols.len() == 1 {
let val = row.get_field_or_json_path(cols[0].as_ref())?;
if val.is_null() {
return None;
}
return Some((val, true));
}
let mut vals = Vec::with_capacity(cols.len());
let mut any_non_null = false;
let mut all_non_null = true;
for col in cols {
let v = row
.get_field_or_json_path(col.as_ref())
.unwrap_or(Value::Null);
if v.is_null() {
all_non_null = false;
} else {
any_non_null = true;
}
vals.push(v);
}
if !any_non_null {
return None;
}
let encoded = serde_json::to_string(&vals).unwrap_or_default();
Some((Value::Text(format!("__comp:{encoded}")), all_non_null))
}
fn collect_table_foreign_keys(table_def: &TableDef) -> Vec<TableForeignKey> {
let mut fks = Vec::new();
for col in &table_def.columns {
if let Some(ref fk) = col.references {
fks.push(TableForeignKey {
name: None,
columns: vec![col.name.clone()],
ref_table: fk.table.clone(),
ref_columns: fk.column.iter().cloned().collect(),
on_delete: fk.on_delete,
on_update: fk.on_update,
});
}
}
fks.extend(table_def.foreign_keys.iter().cloned());
fks
}
fn resolve_fk_parent_cols(parent_def: &TableDef, fk: &TableForeignKey) -> Vec<String> {
if !fk.ref_columns.is_empty() {
fk.ref_columns.clone()
} else if !parent_def.primary_key_columns.is_empty() {
parent_def.primary_key_columns.clone()
} else if let Some(pk) = parent_def.columns.iter().find(|c| c.primary_key) {
vec![pk.name.clone()]
} else {
Vec::new()
}
}
fn eval_where_three_valued(
row: &Row,
expr: &WhereExpr,
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> Option<bool> {
match expr {
WhereExpr::Condition(cond) => {
let val = match row.get_field_or_json_path(&cond.column) {
Some(v) => v,
None => match try_eval_scalar_expr(row, &cond.column, udfs) {
Ok(Some(v)) => v,
_ => return None,
},
};
match cond.op {
BinaryOp::IsNull => Some(val.is_null()),
BinaryOp::IsNotNull => Some(!val.is_null()),
_ => {
if val.is_null() {
None
} else {
Some(matches_condition(&val, &cond.op, &cond.value))
}
}
}
}
WhereExpr::And(l, r) => match (
eval_where_three_valued(row, l, udfs),
eval_where_three_valued(row, r, udfs),
) {
(Some(false), _) | (_, Some(false)) => Some(false),
(Some(true), Some(true)) => Some(true),
_ => None,
},
WhereExpr::Or(l, r) => match (
eval_where_three_valued(row, l, udfs),
eval_where_three_valued(row, r, udfs),
) {
(Some(true), _) | (_, Some(true)) => Some(true),
(Some(false), Some(false)) => Some(false),
_ => None,
},
WhereExpr::InList {
column,
values,
negated,
} => {
let val = row.get_field_or_json_path(column)?;
if val.is_null() {
None
} else {
let found = values.contains(&val);
Some(if *negated { !found } else { found })
}
}
WhereExpr::InSubquery { .. } | WhereExpr::Exists { .. } => Some(true),
}
}
fn value_to_tokens(val: &Value) -> Vec<Token> {
match val {
Value::Null => vec![Token::Null],
Value::Integer(i) if *i < 0 => vec![Token::Dash, Token::IntLit(i.unsigned_abs() as i64)],
Value::Integer(i) => vec![Token::IntLit(*i)],
Value::Real(f) if *f < 0.0 => vec![Token::Dash, Token::FloatLit(-*f)],
Value::Real(f) => vec![Token::FloatLit(*f)],
Value::Text(s) => vec![Token::StringLit(s.clone())],
Value::Blob(b) => vec![Token::BlobLit(b.clone())],
Value::Vector(v) => vec![Token::VectorLit(v.clone())],
}
}
fn token_as_col_name(tok: &Token) -> Option<String> {
crate::sql::parser::parse_token_identifier(tok)
}
fn substitute_trigger_row_tokens(
tokens: &[Token],
old_row: Option<&Row>,
new_row: Option<&Row>,
) -> Vec<Token> {
let mut out = Vec::with_capacity(tokens.len());
let mut i = 0usize;
while i < tokens.len() {
if i + 2 < tokens.len()
&& tokens[i + 1] == Token::Dot
&& let Token::Ident(qualifier) = &tokens[i]
{
let target_row = if qualifier.eq_ignore_ascii_case("NEW") {
new_row
} else if qualifier.eq_ignore_ascii_case("OLD") {
old_row
} else {
None
};
if let Some(row) = target_row
&& let Some(col_name) = token_as_col_name(&tokens[i + 2])
{
let val = row.get_value(&col_name).cloned().unwrap_or(Value::Null);
out.extend(value_to_tokens(&val));
i += 3;
continue;
}
}
out.push(tokens[i].clone());
i += 1;
}
out
}
fn split_token_statements(tokens: &[Token]) -> Vec<Vec<Token>> {
let mut stmts = Vec::new();
let mut current = Vec::new();
let mut depth = 0usize;
for tok in tokens {
match tok {
Token::OpenParen => {
depth += 1;
current.push(tok.clone());
}
Token::CloseParen => {
depth = depth.saturating_sub(1);
current.push(tok.clone());
}
Token::Semicolon if depth == 0 => {
if !current.is_empty() {
stmts.push(std::mem::take(&mut current));
}
}
_ => current.push(tok.clone()),
}
}
if !current.is_empty() {
stmts.push(current);
}
stmts
}
fn collect_and_eq_conditions(expr: &WhereExpr, out: &mut HashMap<String, Value>) {
match expr {
WhereExpr::Condition(c) if c.op == BinaryOp::Equals => {
out.insert(c.column.to_lowercase(), c.value.clone());
}
WhereExpr::And(l, r) => {
collect_and_eq_conditions(l, out);
collect_and_eq_conditions(r, out);
}
_ => {}
}
}
fn collect_and_leaf_predicates(
expr: &WhereExpr,
out: &mut Vec<crate::sql::parser::WhereCondition>,
) {
match expr {
WhereExpr::Condition(c) => out.push(c.clone()),
WhereExpr::And(l, r) => {
collect_and_leaf_predicates(l, out);
collect_and_leaf_predicates(r, out);
}
_ => {}
}
}
fn combine_compound_rows(
left: &mut Vec<Row>,
right: Vec<Row>,
op: crate::sql::parser::SetOperation,
) {
match op {
crate::sql::parser::SetOperation::UnionAll => left.extend(right),
crate::sql::parser::SetOperation::Union => {
let mut seen = HashSet::with_capacity(left.len() + right.len());
left.retain(|r| seen.insert(format!("{:?}", r.values())));
for row in right {
if seen.insert(format!("{:?}", row.values())) {
left.push(row);
}
}
}
}
}
fn apply_cte_column_names(rows: Vec<Row>, explicit_cols: Option<&[String]>) -> Vec<Row> {
let Some(cols) = explicit_cols else {
return rows;
};
rows.into_iter()
.map(|r| {
if r.values().len() == cols.len() {
Row::new(cols.to_vec(), r.values().to_vec())
} else {
let vals = cols
.iter()
.map(|col| r.get_value(col).cloned().unwrap_or(Value::Null))
.collect();
Row::new(cols.to_vec(), vals)
}
})
.collect()
}
fn parse_partial_index_where(predicate_sql: &str) -> Option<WhereExpr> {
let tokens = crate::sql::lexer::tokenize(predicate_sql).ok()?;
let mut cursor = 0usize;
let expr = crate::sql::parser::parse_where_expr_public(&tokens, &mut cursor).ok()?;
if cursor == tokens.len() {
Some(expr)
} else {
None
}
}
fn partial_index_matches_query(index_def: &IndexDef, query_where: Option<&WhereExpr>) -> bool {
let Some(ref pred_sql) = index_def.predicate_sql else {
return true;
};
let Some(q_where) = query_where else {
return false;
};
let Some(pred_expr) = parse_partial_index_where(pred_sql) else {
return false;
};
if pred_expr == *q_where {
return true;
}
let mut pred_conds = Vec::new();
let mut q_conds = Vec::new();
collect_and_leaf_predicates(&pred_expr, &mut pred_conds);
collect_and_leaf_predicates(q_where, &mut q_conds);
if pred_conds.is_empty() {
return false;
}
pred_conds.iter().all(|pc| {
q_conds.iter().any(|qc| {
pc.column.eq_ignore_ascii_case(&qc.column) && pc.op == qc.op && pc.value == qc.value
})
})
}
fn extract_fts_match_query(expr: &WhereExpr, table: &str) -> Option<String> {
match expr {
WhereExpr::Condition(c)
if c.op == BinaryOp::Match && c.column.eq_ignore_ascii_case(table) =>
{
if let Value::Text(ref q) = c.value {
Some(q.clone())
} else {
None
}
}
WhereExpr::And(l, r) | WhereExpr::Or(l, r) => {
extract_fts_match_query(l, table).or_else(|| extract_fts_match_query(r, table))
}
_ => None,
}
}
fn resolve_fts_match_predicate(
expr: &ResolvedWhereExpr,
table: &str,
row_matched: bool,
) -> ResolvedWhereExpr {
match expr {
ResolvedWhereExpr::Condition(c)
if c.op == BinaryOp::Match && c.column.eq_ignore_ascii_case(table) =>
{
ResolvedWhereExpr::Boolean(row_matched)
}
ResolvedWhereExpr::And(l, r) => ResolvedWhereExpr::And(
Box::new(resolve_fts_match_predicate(l, table, row_matched)),
Box::new(resolve_fts_match_predicate(r, table, row_matched)),
),
ResolvedWhereExpr::Or(l, r) => ResolvedWhereExpr::Or(
Box::new(resolve_fts_match_predicate(l, table, row_matched)),
Box::new(resolve_fts_match_predicate(r, table, row_matched)),
),
other => other.clone(),
}
}
#[derive(Debug, Clone)]
pub struct SQLExecutor {
catalog: Catalog,
btree: BTreeStorage,
vector_indexes: HashMap<String, HnswIndex>,
fts_indexes: HashMap<String, Bm25Index>,
graph: GraphEngine,
last_temporal_timestamp: u64,
pub default_system_versioning: bool,
pub foreign_keys_enabled: bool,
trigger_depth: usize,
fk_cascade_depth: usize,
last_insert_rowid: i64,
statement_cache: HashMap<String, Statement>,
statement_cache_order: std::collections::VecDeque<String>,
insert_scratch_buf: Vec<u8>,
insert_scratch_vals: Vec<Value>,
pub udf_registry: crate::sql::udf::UdfRegistry,
}
impl SQLExecutor {
pub fn new(pager: &mut Pager) -> Result<Self> {
let catalog = Catalog::load(pager)?;
let btree = BTreeStorage::new();
let vector_indexes = HashMap::new();
Ok(Self {
catalog,
btree,
vector_indexes,
fts_indexes: HashMap::new(),
graph: GraphEngine::new(),
last_temporal_timestamp: 0,
default_system_versioning: false,
foreign_keys_enabled: true,
trigger_depth: 0,
fk_cascade_depth: 0,
last_insert_rowid: 0,
statement_cache: HashMap::new(),
statement_cache_order: std::collections::VecDeque::new(),
insert_scratch_buf: Vec::with_capacity(256),
insert_scratch_vals: Vec::with_capacity(16),
udf_registry: crate::sql::udf::UdfRegistry::new(),
})
}
pub fn register_scalar_function<F>(&mut self, name: &str, func: F)
where
F: Fn(&[Value]) -> Result<Value> + Send + Sync + 'static,
{
self.udf_registry.register(name, func);
}
pub fn udf_registry(&self) -> &crate::sql::udf::UdfRegistry {
&self.udf_registry
}
pub fn last_insert_rowid(&self) -> i64 {
self.last_insert_rowid
}
pub fn reload_from_pager(&mut self, pager: &mut Pager) -> Result<()> {
self.catalog = Catalog::load(pager)?;
self.fts_indexes.clear();
self.load_graph_from_disk(pager)?;
self.load_vector_indexes_from_disk(pager)?;
Ok(())
}
fn partial_index_matches_row(
&mut self,
pager: &mut Pager,
index_def: &IndexDef,
row: &Row,
) -> Result<bool> {
let Some(ref pred_sql) = index_def.predicate_sql else {
return Ok(true);
};
let tokens = crate::sql::lexer::tokenize(pred_sql)?;
let mut cursor = 0usize;
let expr = crate::sql::parser::parse_where_expr_public(&tokens, &mut cursor)?;
let resolved = self.resolve_where_expr(pager, &expr)?;
Ok(row_matches_resolved(row, &resolved))
}
fn find_usable_index_for_column(
&self,
table: &str,
column: &str,
query_where: Option<&WhereExpr>,
) -> Option<IndexDef> {
let candidates: Vec<&IndexDef> = self
.catalog
.indexes_for_table(table)
.into_iter()
.filter(|idx| {
idx.column.eq_ignore_ascii_case(column)
&& partial_index_matches_query(idx, query_where)
})
.collect();
candidates
.iter()
.copied()
.find(|idx| idx.predicate_sql.is_none())
.or_else(|| candidates.into_iter().next())
.cloned()
}
fn index_add_row(
&mut self,
pager: &mut Pager,
index_def: &IndexDef,
row: &Row,
row_id: u64,
) -> Result<()> {
if !self.partial_index_matches_row(pager, index_def, row)? {
return Ok(());
}
let cols = index_def.target_columns();
if let Some((val, _)) = extract_index_key_value(row, &cols) {
let key = value_to_index_key(&val);
let mut bucket =
if let Some(payload) = self.btree.search(pager, index_def.root_page, key)? {
serde_json::from_slice::<IndexBucket>(&payload)
.unwrap_or_else(|_| IndexBucket::new())
} else {
IndexBucket::new()
};
bucket.add_row_id(val, row_id);
let idx_payload = serde_json::to_vec(&bucket)
.map_err(|e| Error::Corrupted(format!("Failed to serialize index bucket: {e}")))?;
self.btree
.insert(pager, index_def.root_page, key, &idx_payload)?;
}
Ok(())
}
fn index_remove_row(
&mut self,
pager: &mut Pager,
index_def: &IndexDef,
row: &Row,
row_id: u64,
) -> Result<()> {
if !self.partial_index_matches_row(pager, index_def, row)? {
return Ok(());
}
let cols = index_def.target_columns();
if let Some((val, _)) = extract_index_key_value(row, &cols) {
let key = value_to_index_key(&val);
if let Some(payload) = self.btree.search(pager, index_def.root_page, key)?
&& let Ok(mut bucket) = serde_json::from_slice::<IndexBucket>(&payload)
{
bucket.remove_row_id(&val, row_id);
if bucket.is_empty() {
let _ = self.btree.delete(pager, index_def.root_page, key);
} else if let Ok(new_pl) = serde_json::to_vec(&bucket) {
let _ = self.btree.insert(pager, index_def.root_page, key, &new_pl);
}
}
}
Ok(())
}
fn remove_row_from_all_indexes(
&mut self,
pager: &mut Pager,
table: &str,
row: &Row,
row_id: u64,
) -> Result<()> {
for index_def in self.catalog.indexes() {
if index_def.table.eq_ignore_ascii_case(table) {
self.index_remove_row(pager, &index_def, row, row_id)?;
}
}
Ok(())
}
fn add_row_to_all_indexes(
&mut self,
pager: &mut Pager,
table: &str,
row: &Row,
row_id: u64,
) -> Result<()> {
for index_def in self.catalog.indexes() {
if index_def.table.eq_ignore_ascii_case(table) {
self.index_add_row(pager, &index_def, row, row_id)?;
}
}
Ok(())
}
fn validate_unique_constraints(
&mut self,
pager: &mut Pager,
table_def: &TableDef,
candidate_row: &Row,
exclude_row_id: Option<u64>,
) -> Result<()> {
for index_def in self.catalog.indexes() {
if index_def.unique && index_def.table.eq_ignore_ascii_case(&table_def.name) {
if !self.partial_index_matches_row(pager, &index_def, candidate_row)? {
continue;
}
let cols = index_def.target_columns();
if let Some((val, all_non_null)) = extract_index_key_value(candidate_row, &cols)
&& all_non_null
{
let key = value_to_index_key(&val);
if let Some(payload) = self.btree.search(pager, index_def.root_page, key)?
&& let Ok(bucket) = serde_json::from_slice::<IndexBucket>(&payload)
&& let Some(rids) = bucket.get_row_ids(&val)
&& rids.iter().any(|&rid| Some(rid) != exclude_row_id)
{
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {}.{}",
table_def.name,
cols.join(", ")
)));
}
}
}
}
let mut unique_groups: Vec<Vec<String>> = Vec::new();
for col in &table_def.columns {
if col.unique {
unique_groups.push(vec![col.name.clone()]);
}
}
for grp in &table_def.unique_constraints {
if !grp.is_empty() {
unique_groups.push(grp.clone());
}
}
if table_def.primary_key_columns.len() > 1 {
unique_groups.push(table_def.primary_key_columns.clone());
}
if unique_groups.is_empty() {
return Ok(());
}
let candidate_tuples: Vec<Option<Vec<Value>>> = unique_groups
.iter()
.map(|cols| {
let mut vals = Vec::with_capacity(cols.len());
for c in cols {
let v = candidate_row
.get_field_or_json_path(c)
.unwrap_or(Value::Null);
if v.is_null() {
return None;
}
vals.push(v);
}
Some(vals)
})
.collect();
if candidate_tuples.iter().all(Option::is_none) {
return Ok(());
}
let all_cols = table_def.column_names();
let cells = self.btree.scan(pager, table_def.root_page)?;
for cell in cells {
if Some(cell.row_id) == exclude_row_id {
continue;
}
let existing = decode_row(&cell.payload, &all_cols)?;
for (g_idx, cols) in unique_groups.iter().enumerate() {
let Some(ref cand_vals) = candidate_tuples[g_idx] else {
continue;
};
let existing_vals: Vec<Value> = cols
.iter()
.map(|c| existing.get_field_or_json_path(c).unwrap_or(Value::Null))
.collect();
if &existing_vals == cand_vals {
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {}.{}",
table_def.name,
cols.join(", ")
)));
}
}
}
Ok(())
}
fn validate_check_constraints_for_row(&self, table_def: &TableDef, row: &Row) -> Result<()> {
let mut exprs: Vec<(Option<&str>, &str)> = Vec::new();
for col in &table_def.columns {
if let Some(ref expr_sql) = col.check_expr {
exprs.push((Some(col.name.as_str()), expr_sql.as_str()));
}
}
for chk in &table_def.check_constraints {
exprs.push((chk.name.as_deref(), chk.expr_sql.as_str()));
}
for (label, expr_sql) in exprs {
let tokens = tokenize(expr_sql)?;
let mut cursor = 0usize;
let parsed = crate::sql::parser::parse_where_expr_public(&tokens, &mut cursor)?;
if eval_where_three_valued(row, &parsed, Some(&self.udf_registry)) == Some(false) {
let tag = label.unwrap_or("CHECK");
return Err(Error::ConstraintViolation(format!(
"CHECK constraint failed ({tag}) on {}: {expr_sql}",
table_def.name
)));
}
}
Ok(())
}
fn validate_child_foreign_keys(
&self,
pager: &mut Pager,
table_def: &TableDef,
row: &Row,
) -> Result<()> {
if !self.foreign_keys_enabled {
return Ok(());
}
for fk in collect_table_foreign_keys(table_def) {
let child_vals: Vec<Value> = fk
.columns
.iter()
.map(|c| row.get_field_or_json_path(c).unwrap_or(Value::Null))
.collect();
if child_vals.iter().any(Value::is_null) {
continue;
}
let parent_def = self.catalog.get_table(&fk.ref_table).ok_or_else(|| {
Error::ConstraintViolation(format!(
"FOREIGN KEY references non-existent table '{}'",
fk.ref_table
))
})?;
let parent_cols = resolve_fk_parent_cols(parent_def, &fk);
if parent_cols.len() != child_vals.len() {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY column count mismatch between {} and {}",
table_def.name, fk.ref_table
)));
}
if parent_cols.len() == 1
&& parent_def
.primary_key_index()
.and_then(|idx| parent_def.columns.get(idx))
.is_some_and(|pk| pk.name.eq_ignore_ascii_case(&parent_cols[0]))
&& let Value::Integer(pk_id) = child_vals[0]
{
if self
.btree
.search(pager, parent_def.root_page, pk_id as u64)?
.is_some()
{
continue;
} else {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY constraint failed: {}.{} -> {}.{}",
table_def.name,
fk.columns.join(","),
fk.ref_table,
parent_cols.join(",")
)));
}
}
let parent_all_cols = parent_def.column_names();
let cells = self.btree.scan(pager, parent_def.root_page)?;
let mut found = false;
for cell in cells {
let p_row = decode_row(&cell.payload, &parent_all_cols)?;
let p_vals: Vec<Value> = parent_cols
.iter()
.map(|c| p_row.get_field_or_json_path(c).unwrap_or(Value::Null))
.collect();
if p_vals == child_vals {
found = true;
break;
}
}
if !found {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY constraint failed: {}.{} -> {}.{}",
table_def.name,
fk.columns.join(","),
fk.ref_table,
parent_cols.join(",")
)));
}
}
Ok(())
}
fn find_matching_child_rows(
&self,
pager: &mut Pager,
child_def: &TableDef,
child_cols: &[String],
parent_vals: &[Value],
) -> Result<Vec<(u64, Row)>> {
if parent_vals.iter().any(Value::is_null) {
return Ok(Vec::new());
}
let all_cols = child_def.column_names();
let cells = self.btree.scan(pager, child_def.root_page)?;
let mut matches = Vec::new();
for cell in cells {
let row = decode_row(&cell.payload, &all_cols)?;
let c_vals: Vec<Value> = child_cols
.iter()
.map(|c| row.get_field_or_json_path(c).unwrap_or(Value::Null))
.collect();
if c_vals == parent_vals {
matches.push((cell.row_id, row));
}
}
Ok(matches)
}
fn handle_parent_foreign_key_on_delete(
&mut self,
pager: &mut Pager,
parent_table: &str,
old_parent_row: &Row,
) -> Result<()> {
if !self.foreign_keys_enabled {
return Ok(());
}
if self.fk_cascade_depth >= 16 {
return Err(Error::ConstraintViolation(
"FOREIGN KEY CASCADE recursion limit exceeded".into(),
));
}
let parent_def = match self.catalog.get_table(parent_table).cloned() {
Some(d) => d,
None => return Ok(()),
};
let all_tables = self.catalog.tables();
for child_def in all_tables {
for fk in collect_table_foreign_keys(&child_def) {
if !fk.ref_table.eq_ignore_ascii_case(parent_table) {
continue;
}
let parent_cols = resolve_fk_parent_cols(&parent_def, &fk);
let parent_vals: Vec<Value> = parent_cols
.iter()
.map(|c| {
old_parent_row
.get_field_or_json_path(c)
.unwrap_or(Value::Null)
})
.collect();
let matches =
self.find_matching_child_rows(pager, &child_def, &fk.columns, &parent_vals)?;
if matches.is_empty() {
continue;
}
match fk.on_delete {
ForeignKeyAction::NoAction | ForeignKeyAction::Restrict => {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY constraint failed: '{parent_table}' row referenced by '{}.{}'",
child_def.name,
fk.columns.join(",")
)));
}
ForeignKeyAction::Cascade => {
self.fk_cascade_depth += 1;
let mut res = Ok(());
for (child_rid, _) in matches {
if let Some(pk_idx) = child_def.primary_key_index() {
let pk_name = &child_def.columns[pk_idx].name;
let cond = WhereExpr::Condition(WhereCondition {
column: pk_name.clone(),
op: BinaryOp::Equals,
value: Value::Integer(child_rid as i64),
});
res = self
.execute_delete(pager, child_def.name.clone(), Some(cond), None)
.map(|_| ());
} else if let Some(first_col) = fk.columns.first() {
let cond = WhereExpr::Condition(WhereCondition {
column: first_col.clone(),
op: BinaryOp::Equals,
value: parent_vals[0].clone(),
});
res = self
.execute_delete(pager, child_def.name.clone(), Some(cond), None)
.map(|_| ());
}
if res.is_err() {
break;
}
}
self.fk_cascade_depth -= 1;
res?;
}
ForeignKeyAction::SetNull => {
self.fk_cascade_depth += 1;
let mut res = Ok(());
let assignments: Vec<(String, Value)> = fk
.columns
.iter()
.map(|c| (c.clone(), Value::Null))
.collect();
for (idx, col_name) in fk.columns.iter().enumerate() {
if idx < parent_vals.len() {
let cond = WhereExpr::Condition(WhereCondition {
column: col_name.clone(),
op: BinaryOp::Equals,
value: parent_vals[idx].clone(),
});
res = self
.execute_update(
pager,
child_def.name.clone(),
assignments.clone(),
Some(cond),
None,
)
.map(|_| ());
break;
}
}
self.fk_cascade_depth -= 1;
res?;
}
}
}
}
Ok(())
}
fn handle_parent_foreign_key_on_update(
&mut self,
pager: &mut Pager,
parent_table: &str,
old_parent_row: &Row,
new_parent_row: &Row,
) -> Result<()> {
if !self.foreign_keys_enabled {
return Ok(());
}
if self.fk_cascade_depth >= 16 {
return Err(Error::ConstraintViolation(
"FOREIGN KEY CASCADE recursion limit exceeded".into(),
));
}
let parent_def = match self.catalog.get_table(parent_table).cloned() {
Some(d) => d,
None => return Ok(()),
};
let all_tables = self.catalog.tables();
for child_def in all_tables {
for fk in collect_table_foreign_keys(&child_def) {
if !fk.ref_table.eq_ignore_ascii_case(parent_table) {
continue;
}
let parent_cols = resolve_fk_parent_cols(&parent_def, &fk);
let old_vals: Vec<Value> = parent_cols
.iter()
.map(|c| {
old_parent_row
.get_field_or_json_path(c)
.unwrap_or(Value::Null)
})
.collect();
let new_vals: Vec<Value> = parent_cols
.iter()
.map(|c| {
new_parent_row
.get_field_or_json_path(c)
.unwrap_or(Value::Null)
})
.collect();
if old_vals == new_vals {
continue;
}
let matches =
self.find_matching_child_rows(pager, &child_def, &fk.columns, &old_vals)?;
if matches.is_empty() {
continue;
}
match fk.on_update {
ForeignKeyAction::NoAction | ForeignKeyAction::Restrict => {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY constraint failed on UPDATE of '{parent_table}': referenced by '{}.{}'",
child_def.name,
fk.columns.join(",")
)));
}
ForeignKeyAction::Cascade | ForeignKeyAction::SetNull => {
self.fk_cascade_depth += 1;
let target_vals: Vec<Value> = if fk.on_update == ForeignKeyAction::SetNull {
vec![Value::Null; fk.columns.len()]
} else {
new_vals
};
let assignments: Vec<(String, Value)> =
fk.columns.iter().cloned().zip(target_vals).collect();
let cond = WhereExpr::Condition(WhereCondition {
column: fk.columns[0].clone(),
op: BinaryOp::Equals,
value: old_vals[0].clone(),
});
let res = self
.execute_update(
pager,
child_def.name.clone(),
assignments,
Some(cond),
None,
)
.map(|_| ());
self.fk_cascade_depth -= 1;
res?;
}
}
}
}
Ok(())
}
fn ensure_fts_index(&mut self, pager: &mut Pager, table_def: &TableDef) -> Result<()> {
let Some(ref fts_cfg) = table_def.fts_config else {
return Ok(());
};
let key = table_def.name.to_lowercase();
if self.fts_indexes.contains_key(&key) {
return Ok(());
}
let mut idx = Bm25Index::new();
let all_cols = table_def.column_names();
let cells = self.btree.scan(pager, table_def.root_page)?;
for cell in cells {
let row = decode_row(&cell.payload, &all_cols)?;
let mut text = String::new();
for col in &fts_cfg.columns {
if let Some(Value::Text(s)) = row.get_value(col) {
if !text.is_empty() {
text.push(' ');
}
text.push_str(s);
}
}
idx.index_document(cell.row_id, &text);
}
self.fts_indexes.insert(key, idx);
Ok(())
}
fn fts_upsert_row(
&mut self,
pager: &mut Pager,
table_def: &TableDef,
row: &Row,
row_id: u64,
) -> Result<()> {
let Some(ref fts_cfg) = table_def.fts_config else {
return Ok(());
};
self.ensure_fts_index(pager, table_def)?;
let mut text = String::new();
for col in &fts_cfg.columns {
if let Some(Value::Text(s)) = row.get_value(col) {
if !text.is_empty() {
text.push(' ');
}
text.push_str(s);
}
}
if let Some(idx) = self.fts_indexes.get_mut(&table_def.name.to_lowercase()) {
idx.remove_document(row_id);
idx.index_document(row_id, &text);
}
Ok(())
}
fn fts_remove_row(&mut self, table_def: &TableDef, row_id: u64) {
if table_def.fts_config.is_some()
&& let Some(idx) = self.fts_indexes.get_mut(&table_def.name.to_lowercase())
{
idx.remove_document(row_id);
}
}
fn fire_triggers(
&mut self,
pager: &mut Pager,
table: &str,
timing: TriggerTiming,
event: TriggerEvent,
old_row: Option<&Row>,
new_row: Option<&Row>,
) -> Result<bool> {
let triggers = self.catalog.triggers_for(table, timing, event);
if triggers.is_empty() {
return Ok(true);
}
if self.trigger_depth >= 16 {
return Err(Error::ConstraintViolation(
"Trigger recursion depth limit exceeded".into(),
));
}
self.trigger_depth += 1;
let result = (|| -> Result<bool> {
for trig in triggers {
if let Some(ref when_sql) = trig.when_sql {
let when_tokens = tokenize(when_sql)?;
let mut c = 0usize;
let when_expr =
crate::sql::parser::parse_where_expr_public(&when_tokens, &mut c)?;
let resolved = self.resolve_where_expr(pager, &when_expr)?;
let mut t_cols = Vec::new();
let mut t_vals = Vec::new();
if let Some(nr) = new_row {
for (col, val) in nr.columns().iter().zip(nr.values().iter()) {
t_cols.push(format!("NEW.{col}"));
t_vals.push(val.clone());
t_cols.push(col.clone());
t_vals.push(val.clone());
}
}
if let Some(or) = old_row {
for (col, val) in or.columns().iter().zip(or.values().iter()) {
t_cols.push(format!("OLD.{col}"));
t_vals.push(val.clone());
if new_row.is_none() {
t_cols.push(col.clone());
t_vals.push(val.clone());
}
}
}
let trigger_row = Row::new(t_cols, t_vals);
if !row_matches_resolved(&trigger_row, &resolved) {
continue;
}
}
let body_tokens = tokenize(&trig.body_sql)?;
let subst_body = substitute_trigger_row_tokens(&body_tokens, old_row, new_row);
for stmt_tokens in split_token_statements(&subst_body) {
let stmt = parse_tokens(&stmt_tokens)?;
match stmt {
Statement::Raise { action, message } => {
if action.eq_ignore_ascii_case("IGNORE") {
return Ok(false);
}
return Err(Error::ConstraintViolation(format!(
"Trigger '{}' RAISE({action}): {message}",
trig.name
)));
}
other => {
let _ = self.execute_inner(pager, other)?;
}
}
}
}
Ok(true)
})();
self.trigger_depth -= 1;
result
}
pub fn project_row(&self, row: &Row, requested_cols: &[String]) -> Result<Row> {
project_row_with_udf(row, requested_cols, Some(&self.udf_registry))
}
pub fn get_or_parse_statement(&mut self, sql: &str) -> Result<Option<Statement>> {
if let Some(stmt) = self.statement_cache.get(sql) {
return Ok(Some(stmt.clone()));
}
let tokens = crate::sql::lexer::tokenize(sql)?;
if tokens.is_empty() {
return Ok(None);
}
let stmt = crate::sql::parser::parse_tokens(&tokens)?;
if self.statement_cache.len() >= 256
&& let Some(oldest) = self.statement_cache_order.pop_front()
{
self.statement_cache.remove(&oldest);
}
self.statement_cache.insert(sql.to_string(), stmt.clone());
self.statement_cache_order.push_back(sql.to_string());
Ok(Some(stmt))
}
pub fn graph(&self) -> &GraphEngine {
&self.graph
}
pub fn graph_mut(&mut self) -> &mut GraphEngine {
&mut self.graph
}
pub fn project_table_as_nodes(
&mut self,
pager: &mut Pager,
table_name: &str,
id_col: &str,
label_col: Option<&str>,
prop_cols: Option<&[&str]>,
) -> Result<usize> {
let rows = self.query(
pager,
Statement::Select {
distinct: false,
columns: Vec::new(),
table: table_name.to_string(),
from_subquery: None,
join: None,
where_clause: None,
group_by: None,
having: None,
order_by: None,
limit: None,
offset: None,
as_of_timestamp: None,
},
)?;
let mut count = 0;
for row in rows {
let id_val = row
.get_value(id_col)
.ok_or_else(|| Error::ColumnNotFound(id_col.to_string()))?;
let id = match id_val {
Value::Integer(i) => *i as u64,
Value::Text(s) => s.parse::<u64>().unwrap_or_else(|_| {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
s.hash(&mut hasher);
hasher.finish()
}),
other => {
return Err(Error::ConstraintViolation(format!(
"Invalid ID type '{other:?}' for graph node projection"
)));
}
};
let label = if let Some(lc) = label_col {
row.get_value(lc)
.map(|v| v.to_string())
.unwrap_or_else(|| table_name.to_string())
} else {
table_name.to_string()
};
let mut props_map = serde_json::Map::new();
if let Some(cols) = prop_cols {
for &col in cols.iter() {
if let Some(v) = row.get_value(col) {
props_map.insert(col.to_string(), serde_json::json!(v.to_string()));
}
}
} else {
for (name, val) in row.columns().iter().zip(row.values().iter()) {
if name != id_col && label_col.map(|lc| lc != name).unwrap_or(true) {
props_map.insert(name.clone(), serde_json::json!(val.to_string()));
}
}
}
let props_json = serde_json::Value::Object(props_map).to_string();
let vector = row.values().iter().find_map(|v| {
if let Value::Vector(vec) = v {
Some(vec.clone())
} else {
None
}
});
let node = crate::graph::Node {
id,
label,
properties: props_json,
vector,
};
self.graph.restore_node(node.clone());
self.persist_graph_node(pager, &node)?;
count += 1;
}
Ok(count)
}
#[allow(
clippy::too_many_arguments,
reason = "Preserve the public graph projection API"
)]
pub fn project_table_as_edges(
&mut self,
pager: &mut Pager,
table_name: &str,
from_col: &str,
to_col: &str,
label_col: Option<&str>,
weight_col: Option<&str>,
prop_cols: Option<&[&str]>,
) -> Result<usize> {
let rows = self.query(
pager,
Statement::Select {
distinct: false,
columns: Vec::new(),
table: table_name.to_string(),
from_subquery: None,
join: None,
where_clause: None,
group_by: None,
having: None,
order_by: None,
limit: None,
offset: None,
as_of_timestamp: None,
},
)?;
let mut count = 0;
for row in rows {
let from_val = row
.get_value(from_col)
.ok_or_else(|| Error::ColumnNotFound(from_col.to_string()))?;
let to_val = row
.get_value(to_col)
.ok_or_else(|| Error::ColumnNotFound(to_col.to_string()))?;
let from_id = match from_val {
Value::Integer(i) => *i as u64,
Value::Text(s) => s.parse::<u64>().unwrap_or_else(|_| {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
s.hash(&mut hasher);
hasher.finish()
}),
_ => return Err(Error::ConstraintViolation("Invalid from_id type".into())),
};
let to_id = match to_val {
Value::Integer(i) => *i as u64,
Value::Text(s) => s.parse::<u64>().unwrap_or_else(|_| {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
s.hash(&mut hasher);
hasher.finish()
}),
_ => return Err(Error::ConstraintViolation("Invalid to_id type".into())),
};
let label = if let Some(lc) = label_col {
row.get_value(lc)
.map(|v| v.to_string())
.unwrap_or_else(|| "RELATION".to_string())
} else {
"RELATION".to_string()
};
let weight = if let Some(wc) = weight_col {
match row.get_value(wc) {
Some(Value::Real(r)) => *r as f32,
Some(Value::Integer(i)) => *i as f32,
_ => 1.0,
}
} else {
1.0
};
let mut props_map = serde_json::Map::new();
if let Some(cols) = prop_cols {
for &col in cols.iter() {
if let Some(v) = row.get_value(col) {
props_map.insert(col.to_string(), serde_json::json!(v.to_string()));
}
}
} else {
for (name, val) in row.columns().iter().zip(row.values().iter()) {
if name != from_col && name != to_col {
props_map.insert(name.clone(), serde_json::json!(val.to_string()));
}
}
}
let props_json = serde_json::Value::Object(props_map).to_string();
let edge_id = self
.graph
.add_edge(from_id, to_id, label, weight, props_json)?;
if let Some(edge) = self.graph.get_edge(edge_id) {
let edge_clone = edge.clone();
self.persist_graph_edge(pager, &edge_clone)?;
}
count += 1;
}
Ok(count)
}
pub fn vector_indexes(&self) -> &HashMap<String, HnswIndex> {
&self.vector_indexes
}
pub fn vector_indexes_mut(&mut self) -> &mut HashMap<String, HnswIndex> {
&mut self.vector_indexes
}
pub fn set_vector_index(&mut self, table: &str, index: HnswIndex) {
self.vector_indexes.insert(table.to_lowercase(), index);
}
pub fn tables(&self) -> Vec<TableDef> {
self.catalog.tables()
}
pub fn get_table(&self, name: &str) -> Option<&TableDef> {
self.catalog.get_table(name)
}
pub fn views(&self) -> Vec<crate::sql::catalog::ViewDef> {
self.catalog.views()
}
pub fn get_view(&self, name: &str) -> Option<&crate::sql::catalog::ViewDef> {
self.catalog.get_view(name)
}
pub fn ensure_system_table(
&mut self,
pager: &mut Pager,
name: &str,
columns: Vec<ColumnDef>,
) -> Result<u32> {
let name_lower = name.to_lowercase();
if let Some(table) = self.catalog.get_table(&name_lower) {
return Ok(table.root_page);
}
let root_page = pager.allocate_page()?;
let mut root_buf = vec![0u8; pager.page_size()];
engine::init_leaf_page(&mut root_buf, root_page);
pager.write_page(root_page, &root_buf)?;
let table_def = TableDef::new(name.to_string(), root_page, columns);
self.catalog.create_table(pager, table_def)?;
Ok(root_page)
}
pub fn persist_graph_node(
&mut self,
pager: &mut Pager,
node: &crate::graph::Node,
) -> Result<()> {
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Text),
];
let root_page = self.ensure_system_table(pager, "__sys_graph_nodes", cols)?;
let payload = serde_json::to_vec(node)
.map_err(|e| Error::Corrupted(format!("Failed to serialize graph node: {e}")))?;
self.btree.insert(pager, root_page, node.id, &payload)
}
pub fn load_graph_node_adjacency(
&mut self,
pager: &mut Pager,
adj_root: u32,
node_id: u64,
) -> Result<crate::graph::GraphAdjacencyRecord> {
if let Some(payload) = self.btree.search(pager, adj_root, node_id)? {
serde_json::from_slice::<crate::graph::GraphAdjacencyRecord>(&payload).map_err(|e| {
Error::Corrupted(format!(
"Failed to deserialize adjacency for node #{node_id}: {e}"
))
})
} else {
Ok(crate::graph::GraphAdjacencyRecord::default())
}
}
pub fn persist_graph_edge(
&mut self,
pager: &mut Pager,
edge: &crate::graph::Edge,
) -> Result<()> {
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Text),
];
let root_page = self.ensure_system_table(pager, "__sys_graph_edges", cols)?;
let payload = serde_json::to_vec(edge)
.map_err(|e| Error::Corrupted(format!("Failed to serialize graph edge: {e}")))?;
self.btree.insert(pager, root_page, edge.id, &payload)?;
let adj_cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Text),
];
let adj_root = self.ensure_system_table(pager, "__sys_graph_adj", adj_cols)?;
let mut from_adj = self.load_graph_node_adjacency(pager, adj_root, edge.from_id)?;
if !from_adj.outgoing_edges.contains(&edge.id) {
from_adj.outgoing_edges.push(edge.id);
let from_bytes = serde_json::to_vec(&from_adj).map_err(|e| {
Error::Corrupted(format!("Failed to serialize node #{}: {e}", edge.from_id))
})?;
self.btree
.insert(pager, adj_root, edge.from_id, &from_bytes)?;
}
let mut to_adj = self.load_graph_node_adjacency(pager, adj_root, edge.to_id)?;
if !to_adj.incoming_edges.contains(&edge.id) {
to_adj.incoming_edges.push(edge.id);
let to_bytes = serde_json::to_vec(&to_adj).map_err(|e| {
Error::Corrupted(format!("Failed to serialize node #{}: {e}", edge.to_id))
})?;
self.btree.insert(pager, adj_root, edge.to_id, &to_bytes)?;
}
Ok(())
}
pub fn delete_graph_node(&mut self, pager: &mut Pager, id: u64) -> Result<()> {
if let Some(table) = self.catalog.get_table("__sys_graph_nodes") {
let _ = self.btree.delete(pager, table.root_page, id);
}
if let Some(adj_table) = self.catalog.get_table("__sys_graph_adj") {
let _ = self.btree.delete(pager, adj_table.root_page, id);
}
Ok(())
}
pub fn delete_graph_edge(&mut self, pager: &mut Pager, id: u64) -> Result<()> {
let edges_root = match self.catalog.get_table("__sys_graph_edges") {
Some(t) => t.root_page,
None => return Ok(()),
};
let edge_opt = if let Some(bytes) = self.btree.search(pager, edges_root, id)? {
serde_json::from_slice::<crate::graph::Edge>(&bytes).ok()
} else {
None
};
if let Some(edge) = edge_opt {
let _ = self.btree.delete(pager, edges_root, id);
if let Some(adj_table) = self.catalog.get_table("__sys_graph_adj") {
let adj_root = adj_table.root_page;
let mut from_adj = self.load_graph_node_adjacency(pager, adj_root, edge.from_id)?;
if from_adj.outgoing_edges.contains(&id) {
from_adj.outgoing_edges.retain(|&e| e != id);
let bytes = serde_json::to_vec(&from_adj).map_err(|e| {
Error::Corrupted(format!("Failed to serialize node #{}: {e}", edge.from_id))
})?;
self.btree.insert(pager, adj_root, edge.from_id, &bytes)?;
}
let mut to_adj = self.load_graph_node_adjacency(pager, adj_root, edge.to_id)?;
if to_adj.incoming_edges.contains(&id) {
to_adj.incoming_edges.retain(|&e| e != id);
let bytes = serde_json::to_vec(&to_adj).map_err(|e| {
Error::Corrupted(format!("Failed to serialize node #{}: {e}", edge.to_id))
})?;
self.btree.insert(pager, adj_root, edge.to_id, &bytes)?;
}
}
}
Ok(())
}
pub fn get_disk_graph_neighbors(
&mut self,
pager: &mut Pager,
node_id: u64,
direction: crate::graph::Direction,
edge_label: Option<&str>,
) -> Result<Vec<(crate::graph::Node, crate::graph::Edge)>> {
let adj_root = match self.catalog.get_table("__sys_graph_adj") {
Some(t) => t.root_page,
None => return Ok(Vec::new()),
};
let edges_root = match self.catalog.get_table("__sys_graph_edges") {
Some(t) => t.root_page,
None => return Ok(Vec::new()),
};
let nodes_root = match self.catalog.get_table("__sys_graph_nodes") {
Some(t) => t.root_page,
None => return Ok(Vec::new()),
};
let adj = self.load_graph_node_adjacency(pager, adj_root, node_id)?;
let mut candidate_edges = Vec::new();
match direction {
crate::graph::Direction::Outgoing => {
candidate_edges.extend(adj.outgoing_edges);
}
crate::graph::Direction::Incoming => {
candidate_edges.extend(adj.incoming_edges);
}
crate::graph::Direction::Both => {
candidate_edges.extend(adj.outgoing_edges);
for e in adj.incoming_edges {
if !candidate_edges.contains(&e) {
candidate_edges.push(e);
}
}
}
}
let mut results = Vec::new();
for eid in candidate_edges {
if let Some(edge_bytes) = self.btree.search(pager, edges_root, eid)?
&& let Ok(edge) = serde_json::from_slice::<crate::graph::Edge>(&edge_bytes)
{
if let Some(filter_label) = edge_label
&& !edge.label.eq_ignore_ascii_case(filter_label)
{
continue;
}
let neighbor_id = if edge.from_id == node_id {
edge.to_id
} else {
edge.from_id
};
if let Some(node_bytes) = self.btree.search(pager, nodes_root, neighbor_id)?
&& let Ok(node) = serde_json::from_slice::<crate::graph::Node>(&node_bytes)
{
results.push((node, edge));
}
}
}
Ok(results)
}
pub fn load_graph_from_disk(&mut self, pager: &mut Pager) -> Result<()> {
if let Some(table) = self.catalog.get_table("__sys_graph_nodes") {
let root_page = table.root_page;
let cells = self.btree.scan(pager, root_page)?;
for cell in cells {
if let Ok(node) = serde_json::from_slice::<crate::graph::Node>(&cell.payload) {
self.graph.restore_node(node);
}
}
}
if let Some(table) = self.catalog.get_table("__sys_graph_edges") {
let root_page = table.root_page;
let cells = self.btree.scan(pager, root_page)?;
for cell in cells {
if let Ok(edge) = serde_json::from_slice::<crate::graph::Edge>(&cell.payload) {
self.graph.restore_edge(edge);
}
}
}
Ok(())
}
pub fn persist_memory_entry(
&mut self,
pager: &mut Pager,
entry: &crate::memory::MemoryEntry,
) -> Result<()> {
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Blob),
];
let root_page = self.ensure_system_table(pager, "__sys_memory", cols)?;
let payload = crate::memory::binary::encode_memory_entry_binary(entry)?;
self.btree.insert(pager, root_page, entry.id, &payload)
}
pub fn delete_memory_entry(&mut self, pager: &mut Pager, id: u64) -> Result<bool> {
if let Some(table) = self.catalog.get_table("__sys_memory") {
let root_page = table.root_page;
self.btree.delete(pager, root_page, id)
} else {
Ok(false)
}
}
pub fn load_memory_from_disk(
&self,
pager: &mut Pager,
memory_engine: &mut crate::memory::MemoryEngine,
) -> Result<()> {
if let Some(table) = self.catalog.get_table("__sys_memory") {
let root_page = table.root_page;
self.btree.scan_with_ref(pager, root_page, |id, payload| {
let entry = crate::memory::binary::decode_memory_entry_auto(id, payload)?;
if entry.id != id {
return Err(Error::Corrupted(format!(
"Memory record key {id} does not match payload ID {}",
entry.id
)));
}
memory_engine.restore_entry(entry)?;
Ok(true)
})?;
}
if let Some(idx_table) = self.catalog.get_table("__sys_memory_index")
&& let Ok(Some(payload)) = self.btree.search(pager, idx_table.root_page, 1)
{
let _ = memory_engine.import_cached_indexes(&payload);
}
Ok(())
}
pub fn persist_memory_index_to_disk(
&mut self,
pager: &mut Pager,
memory_engine: &mut crate::memory::MemoryEngine,
) -> Result<()> {
if memory_engine.stats().documents == 0 && !self.catalog.table_exists("__sys_memory_index")
{
return Ok(());
}
if let Some(payload) = memory_engine.export_cached_indexes()? {
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Blob),
];
let root_page = self.ensure_system_table(pager, "__sys_memory_index", cols)?;
self.btree.insert(pager, root_page, 1, &payload)?;
memory_engine.mark_index_cache_synced();
}
Ok(())
}
pub fn next_temporal_timestamp(&mut self) -> u64 {
let now = web_time::SystemTime::now()
.duration_since(web_time::UNIX_EPOCH)
.unwrap_or_default()
.as_secs();
let ts = if now <= self.last_temporal_timestamp {
self.last_temporal_timestamp + 1
} else {
now
};
self.last_temporal_timestamp = ts;
ts
}
pub fn record_temporal_version(
&mut self,
pager: &mut Pager,
table: &str,
row_id: u64,
payload: &[u8],
valid_from: u64,
valid_to: u64,
) -> Result<()> {
if table.starts_with("__sys_") {
return Ok(());
}
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Blob),
];
let root_page = self.ensure_system_table(pager, "__sys_time_travel", cols)?;
let version_id = {
let tdef = self
.catalog
.get_table_mut("__sys_time_travel")
.ok_or_else(|| Error::TableNotFound("__sys_time_travel".into()))?;
let vid = tdef.next_row_id;
tdef.next_row_id += 1;
vid
};
let record = TemporalRecord {
id: version_id,
table_name: table.to_string(),
row_id,
valid_from,
valid_to,
payload: payload.to_vec(),
};
let rec_payload = serde_json::to_vec(&record)
.map_err(|e| Error::Corrupted(format!("Failed to serialize temporal record: {e}")))?;
self.btree
.insert(pager, root_page, version_id, &rec_payload)?;
Ok(())
}
pub fn close_temporal_version(
&mut self,
pager: &mut Pager,
table: &str,
row_id: u64,
end_time: u64,
) -> Result<()> {
if table.starts_with("__sys_") {
return Ok(());
}
if let Some(tdef) = self.catalog.get_table("__sys_time_travel") {
let root_page = tdef.root_page;
let cells = self.btree.scan(pager, root_page)?;
for cell in cells {
if let Ok(mut record) = serde_json::from_slice::<TemporalRecord>(&cell.payload)
&& record.table_name.eq_ignore_ascii_case(table)
&& record.row_id == row_id
&& record.valid_to == u64::MAX
{
record.valid_to = end_time;
let updated_payload = serde_json::to_vec(&record).map_err(|e| {
Error::Corrupted(format!("Failed to serialize temporal record: {e}"))
})?;
self.btree
.insert(pager, root_page, cell.row_id, &updated_payload)?;
break;
}
}
}
Ok(())
}
pub fn persist_vector_indexes_to_disk(&mut self, pager: &mut Pager) -> Result<()> {
if self.vector_indexes.is_empty() {
return Ok(());
}
let cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("table_name", DataType::Text),
ColumnDef::new("snapshot", DataType::Blob),
];
let root_page = self.ensure_system_table(pager, "__sys_vector_snapshots", cols)?;
pager.set_vector_index_page(root_page as u32)?;
for (table_name, index) in &self.vector_indexes {
let key = {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
table_name.to_lowercase().hash(&mut hasher);
let h = hasher.finish();
if h == 0 { 1 } else { h }
};
let record = VectorSnapshotRecord {
table_name: table_name.clone(),
snapshot: index.export_snapshot(),
table_fingerprint: Some(self.table_fingerprint(pager, table_name)?),
};
let payload = serde_json::to_vec(&record)
.map_err(|e| Error::Corrupted(format!("Failed to serialize HNSW snapshot: {e}")))?;
self.btree.insert(pager, root_page, key, &payload)?;
}
Ok(())
}
fn table_fingerprint(&self, pager: &mut Pager, table: &str) -> Result<u32> {
let definition = self
.catalog
.get_table(table)
.ok_or_else(|| Error::TableNotFound(table.into()))?;
let mut hash = crc32fast::Hasher::new();
for cell in self.btree.scan(pager, definition.root_page)? {
hash.update(&cell.row_id.to_le_bytes());
hash.update(&cell.payload);
}
Ok(hash.finalize())
}
pub fn load_vector_indexes_from_disk(&mut self, pager: &mut Pager) -> Result<()> {
self.vector_indexes.clear();
let mut loaded_tables = HashSet::new();
let snap_root = self
.catalog
.get_table("__sys_vector_snapshots")
.map(|t| t.root_page)
.or_else(|| {
let p = pager.vector_index_page();
if p != 0 { Some(p) } else { None }
});
if let Some(root_page) = snap_root
&& let Ok(cells) = self.btree.scan(pager, root_page)
{
for cell in cells {
if let Ok(rec) = serde_json::from_slice::<VectorSnapshotRecord>(&cell.payload) {
if !self.catalog.table_exists(&rec.table_name)
|| rec.table_fingerprint
!= Some(self.table_fingerprint(pager, &rec.table_name)?)
{
continue;
}
let index = HnswIndex::import_snapshot(rec.snapshot);
self.vector_indexes
.insert(rec.table_name.to_lowercase(), index);
loaded_tables.insert(rec.table_name.to_lowercase());
}
}
}
for table in self.catalog.tables() {
let tname = table.name.to_lowercase();
if !loaded_tables.contains(&tname)
&& let Some((vec_idx, dims)) = table.vector_column()
{
let mut index = HnswIndex::new(dims, DistanceMetric::Cosine);
let cells = self.btree.scan(pager, table.root_page)?;
let all_col_names = table.column_names();
for cell in cells {
if let Ok(row) = decode_row(&cell.payload, &all_col_names)
&& let Some(crate::traits::Value::Vector(vec)) = row.values().get(vec_idx)
{
index.insert_vector(cell.row_id, vec)?;
}
}
self.vector_indexes.insert(tname, index);
}
}
Ok(())
}
pub fn persist_paged_vector_index(
&mut self,
pager: &mut Pager,
table_name: &str,
paged_index: &crate::vector::PagedHnswIndex,
) -> Result<()> {
let meta_cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("table_name", DataType::Text),
ColumnDef::new("header", DataType::Blob),
];
let meta_root = self.ensure_system_table(pager, "__sys_paged_vec_meta", meta_cols)?;
let key = {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
table_name.to_lowercase().hash(&mut hasher);
let h = hasher.finish();
if h == 0 { 1 } else { h }
};
let header = paged_index.export_header();
let header_bytes = serde_json::to_vec(&header)
.map_err(|e| Error::Corrupted(format!("Failed to serialize PagedHnswHeader: {e}")))?;
self.btree.insert(pager, meta_root, key, &header_bytes)?;
let vec_table_name = format!("__sys_paged_vec_{}", table_name.to_lowercase());
let page_cols = vec![
ColumnDef::new("id", DataType::Integer).primary_key(),
ColumnDef::new("payload", DataType::Blob),
];
let page_root = self.ensure_system_table(pager, &vec_table_name, page_cols)?;
for (node_id, page_bytes) in paged_index.store.dump_pages() {
self.btree.insert(pager, page_root, node_id, &page_bytes)?;
}
Ok(())
}
pub fn load_paged_vector_index(
&mut self,
pager: &mut Pager,
table_name: &str,
cache_capacity: usize,
) -> Result<Option<crate::vector::PagedHnswIndex>> {
let meta_root = match self.catalog.get_table("__sys_paged_vec_meta") {
Some(t) => t.root_page,
None => return Ok(None),
};
let key = {
use std::hash::{Hash, Hasher};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
table_name.to_lowercase().hash(&mut hasher);
let h = hasher.finish();
if h == 0 { 1 } else { h }
};
let header_opt = self.btree.search(pager, meta_root, key)?;
let header_bytes = match header_opt {
Some(b) => b,
None => return Ok(None),
};
let header = serde_json::from_slice::<crate::vector::PagedHnswHeader>(&header_bytes)
.map_err(|e| Error::Corrupted(format!("Failed to deserialize PagedHnswHeader: {e}")))?;
let store = crate::vector::PagedVectorStore::new(cache_capacity);
let vec_table_name = format!("__sys_paged_vec_{}", table_name.to_lowercase());
if let Some(t) = self.catalog.get_table(&vec_table_name) {
let cells = self.btree.scan(pager, t.root_page)?;
for cell in cells {
store.load_page(cell.row_id, cell.payload);
}
}
Ok(Some(crate::vector::PagedHnswIndex::import_header(
header, store,
)))
}
pub fn resolve_where_expr(
&mut self,
pager: &mut Pager,
expr: &WhereExpr,
) -> Result<ResolvedWhereExpr> {
match expr {
WhereExpr::Condition(cond) => Ok(ResolvedWhereExpr::Condition(cond.clone())),
WhereExpr::And(left, right) => {
let l = self.resolve_where_expr(pager, left)?;
let r = self.resolve_where_expr(pager, right)?;
Ok(ResolvedWhereExpr::And(Box::new(l), Box::new(r)))
}
WhereExpr::Or(left, right) => {
let l = self.resolve_where_expr(pager, left)?;
let r = self.resolve_where_expr(pager, right)?;
Ok(ResolvedWhereExpr::Or(Box::new(l), Box::new(r)))
}
WhereExpr::InList {
column,
values,
negated,
} => Ok(ResolvedWhereExpr::InList {
column: column.clone(),
values: values.clone(),
negated: *negated,
}),
WhereExpr::InSubquery {
column,
subquery,
negated,
} => {
let sub_rows = self.query(pager, *subquery.clone())?;
let mut values = Vec::new();
for r in sub_rows {
if let Some(v) = r.values().first() {
values.push(v.clone());
}
}
Ok(ResolvedWhereExpr::InList {
column: column.clone(),
values,
negated: *negated,
})
}
WhereExpr::Exists { subquery, negated } => {
let sub_rows = self.query(pager, *subquery.clone())?;
let exists = !sub_rows.is_empty();
let matches = if *negated { !exists } else { exists };
Ok(ResolvedWhereExpr::Boolean(matches))
}
}
}
pub fn execute(&mut self, pager: &mut Pager, stmt: Statement) -> Result<usize> {
if Self::is_mutation(&stmt) {
self.atomic_statement(pager, |executor, pager| executor.execute_inner(pager, stmt))
} else {
self.execute_inner(pager, stmt)
}
}
fn is_mutation(stmt: &Statement) -> bool {
matches!(
stmt,
Statement::CreateTable { .. }
| Statement::Insert { .. }
| Statement::InsertMany { .. }
| Statement::Update { .. }
| Statement::Delete { .. }
| Statement::GraphInsertNode { .. }
| Statement::GraphInsertEdge { .. }
| Statement::CreateIndex { .. }
| Statement::DropTable { .. }
| Statement::DropIndex { .. }
| Statement::AlterTableAddColumn { .. }
| Statement::AlterTableDropColumn { .. }
| Statement::AlterTableRenameColumn { .. }
| Statement::AlterTableRenameTable { .. }
| Statement::CreateView { .. }
| Statement::DropView { .. }
| Statement::CreateTrigger { .. }
| Statement::DropTrigger { .. }
| Statement::CopyFrom { .. }
)
}
pub(crate) fn atomic_statement<T>(
&mut self,
pager: &mut Pager,
operation: impl FnOnce(&mut Self, &mut Pager) -> Result<T>,
) -> Result<T> {
let own = !pager.is_in_transaction();
let savepoint = format!("__tapirus_statement_{}", pager.savepoint_depth());
if own {
pager.begin_transaction()?;
} else {
pager.create_savepoint(&savepoint)?;
}
match operation(self, pager) {
Ok(value) => {
let commit = if own {
pager.commit_transaction()
} else {
pager.release_savepoint(&savepoint)
};
if let Err(error) = commit {
if pager.is_in_transaction() {
let _ = pager.rollback_transaction();
}
self.reload_from_pager(pager)?;
return Err(error);
}
Ok(value)
}
Err(error) => {
if own {
pager.rollback_transaction()?;
} else {
pager.rollback_to_savepoint(&savepoint)?;
pager.release_savepoint(&savepoint)?;
}
self.reload_from_pager(pager)?;
Err(error)
}
}
}
fn execute_inner(&mut self, pager: &mut Pager, stmt: Statement) -> Result<usize> {
match stmt {
Statement::InsertMany {
table,
columns,
rows,
conflict_action,
returning,
} => {
let mut affected = 0;
let mut returned = Vec::new();
for values in rows {
let (count, result) = self.execute_insert(
pager,
table.clone(),
columns.clone(),
values,
conflict_action.clone(),
returning.clone(),
)?;
affected += count;
returned.extend(result);
}
Ok(affected)
}
Statement::Pragma { key, value } => {
let k = key.to_lowercase();
if k == "time_travel" || k == "system_versioning" || k == "temporal" {
if let Some(v) = value {
let val_lower = v.trim().to_lowercase();
self.default_system_versioning =
val_lower == "1" || val_lower == "true" || val_lower == "on";
}
Ok(if self.default_system_versioning { 1 } else { 0 })
} else if k == "foreign_keys" {
if let Some(v) = value {
let val_lower = v.trim().to_lowercase();
self.foreign_keys_enabled =
val_lower == "1" || val_lower == "true" || val_lower == "on";
}
Ok(if self.foreign_keys_enabled { 1 } else { 0 })
} else {
Ok(0)
}
}
Statement::CreateTable {
name,
if_not_exists,
columns,
system_versioning,
foreign_keys,
check_constraints,
unique_constraints,
primary_key_columns,
fts_config,
} => {
if self.catalog.table_exists(&name) {
if if_not_exists {
return Ok(0);
} else {
return Err(Error::TableExists(name));
}
}
let root_page = pager.allocate_page()?;
let mut root_buf = vec![0u8; pager.page_size()];
engine::init_leaf_page(&mut root_buf, root_page);
pager.write_page(root_page, &root_buf)?;
let mut table_def = TableDef::new(name.clone(), root_page, columns);
table_def.system_versioning = system_versioning || self.default_system_versioning;
table_def.foreign_keys = foreign_keys;
table_def.check_constraints = check_constraints;
table_def.unique_constraints = unique_constraints;
table_def.primary_key_columns = primary_key_columns;
table_def.fts_config = fts_config.clone();
if let Some((_, dims)) = table_def.vector_column() {
let index = HnswIndex::new(dims, DistanceMetric::Cosine);
self.vector_indexes.insert(name.to_lowercase(), index);
}
if fts_config.is_some() {
self.fts_indexes
.insert(name.to_lowercase(), Bm25Index::new());
}
self.catalog.create_table(pager, table_def)?;
Ok(1)
}
Statement::Insert {
table,
columns,
values,
conflict_action,
returning,
} => {
let (affected, _) =
self.execute_insert(pager, table, columns, values, conflict_action, returning)?;
Ok(affected)
}
Statement::GraphInsertNode {
id,
label,
properties,
} => {
let node = crate::graph::Node {
id,
label,
properties,
vector: None,
};
self.graph.restore_node(node.clone());
self.persist_graph_node(pager, &node)?;
Ok(1)
}
Statement::GraphInsertEdge {
from_id,
to_id,
label,
weight,
properties,
} => {
let edge_id = self
.graph
.add_edge(from_id, to_id, label, weight, properties)?;
if let Some(edge) = self.graph.get_edge(edge_id) {
let edge_clone = edge.clone();
self.persist_graph_edge(pager, &edge_clone)?;
}
Ok(1)
}
Statement::Update {
table,
assignments,
where_clause,
returning,
} => {
let (affected, _) =
self.execute_update(pager, table, assignments, where_clause, returning)?;
Ok(affected)
}
Statement::Delete {
table,
where_clause,
returning,
} => {
let (affected, _) = self.execute_delete(pager, table, where_clause, returning)?;
Ok(affected)
}
Statement::BeginTransaction => {
pager.begin_transaction()?;
Ok(0)
}
Statement::CommitTransaction => {
self.persist_vector_indexes_to_disk(pager)?;
pager.commit_transaction()?;
Ok(0)
}
Statement::RollbackTransaction => {
pager.rollback_transaction()?;
self.catalog = Catalog::load(pager)?;
self.vector_indexes.clear();
self.fts_indexes.clear();
self.graph = GraphEngine::new();
self.load_vector_indexes_from_disk(pager)?;
self.load_graph_from_disk(pager)?;
Ok(0)
}
Statement::CreateIndex {
name,
if_not_exists,
table,
column,
columns,
unique,
where_clause,
predicate_sql,
} => {
if if_not_exists && self.catalog.index_exists(&name) {
return Ok(0);
}
if self.catalog.index_exists(&name) {
return Err(Error::TableExists(format!("Index '{name}' already exists")));
}
let table_def = self
.catalog
.get_table(&table)
.cloned()
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
let target_cols = if columns.is_empty() {
vec![column.clone()]
} else {
columns
};
for col in &target_cols {
let base_col = col.split('.').next().unwrap_or(col);
if table_def.column_index(base_col).is_none()
&& table_def.column_index(col).is_none()
{
return Err(Error::Corrupted(format!(
"Column '{col}' not found in table '{table}' for index '{name}'"
)));
}
}
let resolved_predicate = match where_clause {
Some(ref expr) => Some(self.resolve_where_expr(pager, expr)?),
None => None,
};
let index_root = pager.allocate_page()?;
let mut index_buf = vec![0u8; pager.page_size()];
engine::init_leaf_page(&mut index_buf, index_root);
pager.write_page(index_root, &index_buf)?;
let cells = self.btree.scan(pager, table_def.root_page)?;
let all_col_names = table_def.column_names();
let mut buckets: HashMap<u64, IndexBucket> = HashMap::new();
for cell in cells {
let full_row = decode_row(&cell.payload, &all_col_names)?;
if let Some(ref pred) = resolved_predicate
&& !row_matches_resolved(&full_row, pred)
{
continue;
}
if let Some((col_val, all_non_null)) =
extract_index_key_value(&full_row, &target_cols)
{
let key = value_to_index_key(&col_val);
let bucket = buckets.entry(key).or_default();
if unique
&& all_non_null
&& bucket.get_row_ids(&col_val).is_some_and(|r| !r.is_empty())
{
return Err(Error::ConstraintViolation(format!(
"UNIQUE index '{name}' failed: duplicate key in {table}({})",
target_cols.join(", ")
)));
}
bucket.add_row_id(col_val, cell.row_id);
}
}
for (key, bucket) in buckets {
let idx_payload = serde_json::to_vec(&bucket).map_err(|e| {
Error::Corrupted(format!("Failed to serialize index bucket: {e}"))
})?;
self.btree.insert(pager, index_root, key, &idx_payload)?;
}
let index_def = IndexDef::composite(name, table, target_cols, index_root, unique)
.with_predicate(predicate_sql);
self.catalog.create_index(pager, index_def)?;
Ok(1)
}
Statement::Vacuum { into } => {
if let Some(dest_file) = into {
let pages_written = pager.backup_to(std::path::Path::new(&dest_file))?;
Ok(pages_written as usize)
} else {
let cp = pager.checkpoint()?;
for index in self.vector_indexes.values_mut() {
index.vacuum();
}
let _ = self.persist_vector_indexes_to_disk(pager);
Ok(cp)
}
}
Statement::DropTable { table, if_exists } => {
let name_lower = table.to_lowercase();
if let Some(table_def) = self.catalog.get_table(&name_lower).cloned() {
if self.foreign_keys_enabled {
for child_def in self.catalog.tables() {
if child_def.name.eq_ignore_ascii_case(&table) {
continue;
}
for fk in collect_table_foreign_keys(&child_def) {
if fk.ref_table.eq_ignore_ascii_case(&table) {
let child_cols = child_def.column_names();
let cells = self.btree.scan(pager, child_def.root_page)?;
for cell in cells {
let row = decode_row(&cell.payload, &child_cols)?;
let has_non_null_ref = fk.columns.iter().all(|c| {
!row.get_field_or_json_path(c)
.unwrap_or(Value::Null)
.is_null()
});
if has_non_null_ref {
return Err(Error::ConstraintViolation(format!(
"FOREIGN KEY constraint failed on DROP TABLE '{table}': referenced by '{}'",
child_def.name
)));
}
}
}
}
}
}
let root_page = table_def.root_page;
let mut page_buf = pager.read_page(root_page)?;
engine::init_leaf_page(&mut page_buf, root_page);
pager.write_page(root_page, &page_buf)?;
let index_names: Vec<String> = self
.catalog
.indexes()
.into_iter()
.filter(|i| i.table.eq_ignore_ascii_case(&table))
.map(|i| i.name)
.collect();
for idx_name in index_names {
let _ = self.catalog.drop_index(pager, &idx_name);
}
let trigger_names: Vec<String> = self
.catalog
.triggers()
.into_iter()
.filter(|t| t.table.eq_ignore_ascii_case(&table))
.map(|t| t.name)
.collect();
for trg_name in trigger_names {
let _ = self.catalog.drop_trigger(pager, &trg_name);
}
self.catalog.drop_table(pager, &table)?;
self.vector_indexes.remove(&name_lower);
self.fts_indexes.remove(&name_lower);
Ok(1)
} else if if_exists {
Ok(0)
} else {
Err(Error::TableNotFound(table))
}
}
Statement::AlterTableAddColumn { table, column } => {
let default_fill = column.default_value.as_ref().map(DefaultValue::materialize);
self.catalog.add_column(pager, &table, column)?;
if let Some(fill_val) = default_fill
&& let Some(tdef) = self.catalog.get_table(&table).cloned()
{
let col_count = tdef.columns.len();
let prev_cols: Vec<String> = tdef
.columns
.iter()
.take(col_count.saturating_sub(1))
.map(|c| c.name.clone())
.collect();
let cells = self.btree.scan(pager, tdef.root_page)?;
for cell in cells {
let row = decode_row(&cell.payload, &prev_cols)?;
let mut vals = row.values().to_vec();
if vals.len() < col_count {
vals.resize(col_count - 1, Value::Null);
vals.push(fill_val.clone());
let new_payload = encode_row(&vals);
self.btree
.insert(pager, tdef.root_page, cell.row_id, &new_payload)?;
}
}
}
Ok(1)
}
Statement::AlterTableRenameTable { table, new_name } => {
self.catalog.rename_table(pager, &table, &new_name)?;
Ok(1)
}
Statement::AlterTableRenameColumn {
table,
old_name,
new_name,
} => {
self.catalog
.rename_column(pager, &table, &old_name, &new_name)?;
Ok(1)
}
Statement::AlterTableDropColumn { table, column } => {
self.catalog.drop_column(pager, &table, &column)?;
Ok(1)
}
Statement::Savepoint { name } => {
pager.create_savepoint(&name)?;
Ok(0)
}
Statement::RollbackToSavepoint { name } => {
pager.rollback_to_savepoint(&name)?;
self.catalog = Catalog::load(pager)?;
self.vector_indexes.clear();
self.fts_indexes.clear();
self.graph = GraphEngine::new();
self.load_vector_indexes_from_disk(pager)?;
self.load_graph_from_disk(pager)?;
Ok(0)
}
Statement::CreateTrigger {
name,
if_not_exists,
table,
timing,
event,
when_sql,
body_sql,
} => {
if if_not_exists && self.catalog.trigger_exists(&name) {
return Ok(0);
}
if !self.catalog.table_exists(&table) {
return Err(Error::TableNotFound(table));
}
let trg = TriggerDef {
name,
table,
timing,
event,
when_sql,
body_sql,
};
self.catalog.create_trigger(pager, trg)?;
Ok(1)
}
Statement::DropTrigger { name, if_exists } => {
let dropped = self.catalog.drop_trigger(pager, &name)?;
if dropped {
Ok(1)
} else if if_exists {
Ok(0)
} else {
Err(Error::TableNotFound(format!("Trigger '{name}' not found")))
}
}
Statement::Raise { action, message } => Err(Error::ConstraintViolation(format!(
"RAISE({action}): {message}"
))),
Statement::ReleaseSavepoint { name } => {
pager.release_savepoint(&name)?;
Ok(0)
}
Statement::CreateView {
name,
if_not_exists,
query_sql,
..
} => {
let name_lower = name.to_lowercase();
if self.catalog.view_exists(&name_lower) {
if if_not_exists {
return Ok(0);
} else {
return Err(Error::TableExists(format!("View '{name}' already exists")));
}
}
if self.catalog.table_exists(&name_lower) {
return Err(Error::TableExists(format!(
"Table with name '{name}' already exists"
)));
}
let view_def = crate::sql::catalog::ViewDef::new(name, query_sql);
self.catalog.create_view(pager, view_def)?;
Ok(1)
}
Statement::DropView { name, if_exists } => {
let dropped = self.catalog.drop_view(pager, &name)?;
if dropped {
Ok(1)
} else if if_exists {
Ok(0)
} else {
Err(Error::TableNotFound(format!("View '{name}' not found")))
}
}
Statement::DropIndex { name, if_exists } => {
if let Some(idx_def) = self.catalog.get_index(&name).cloned() {
let root_page = idx_def.root_page;
if root_page > 0 {
let mut page_buf = pager.read_page(root_page)?;
engine::init_leaf_page(&mut page_buf, root_page);
pager.write_page(root_page, &page_buf)?;
}
self.catalog.drop_index(pager, &name)?;
Ok(1)
} else if if_exists {
Ok(0)
} else {
Err(Error::TableNotFound(format!("Index '{name}' not found")))
}
}
Statement::Analyze { table } => {
let tables_to_analyze: Vec<String> = if let Some(t) = table {
vec![t]
} else {
self.catalog.tables().into_iter().map(|t| t.name).collect()
};
let mut analyzed_count = 0;
for tname in tables_to_analyze {
if let Some(tdef) = self.catalog.get_table(&tname).cloned() {
let cells = self.btree.scan(pager, tdef.root_page)?;
let total_rows = cells.len();
let all_cols = tdef.column_names();
let mut distinct_map = HashMap::new();
let mut null_map = HashMap::new();
let mut total_bytes = 0;
for col in &all_cols {
distinct_map.insert(col.clone(), std::collections::HashSet::new());
null_map.insert(col.clone(), 0usize);
}
for cell in &cells {
total_bytes += cell.payload.len();
if let Ok(row) = decode_row(&cell.payload, &all_cols) {
for col in &all_cols {
if let Some(v) = row.get_field_or_json_path(col) {
if v.is_null() {
if let Some(n) = null_map.get_mut(col) {
*n += 1;
}
} else {
if let Some(set) = distinct_map.get_mut(col) {
let key = format!("{v:?}");
set.insert(key);
}
}
}
}
}
}
let mut column_distinct = HashMap::new();
for (k, v) in distinct_map {
column_distinct.insert(k, v.len());
}
let page_count = (total_bytes / pager.page_size()).max(1);
let mut stats =
crate::sql::planner::TableStats::new(&tname, total_rows, page_count);
stats.column_distinct = column_distinct;
stats.column_nulls = null_map;
self.catalog.set_table_stats(&tname, stats);
analyzed_count += 1;
}
}
Ok(analyzed_count)
}
Statement::Select { .. }
| Statement::ExternalScan { .. }
| Statement::VectorSearch { .. }
| Statement::Explain { .. }
| Statement::GraphTraverse { .. }
| Statement::GraphShortestPath { .. }
| Statement::GraphMatch { .. }
| Statement::GraphAlgorithm { .. }
| Statement::WithCte { .. }
| Statement::Compound { .. } => Err(Error::SqlSyntax(
"Query statement passed to execute(); use query() instead".into(),
)),
Statement::CopyFrom {
table,
source,
format,
options,
} => self.execute_copy_from(pager, &table, &source, format.as_deref(), &options),
Statement::CopyTo {
source_table,
source_query,
dest,
format,
partition_by,
} => self.execute_copy_to(
pager,
source_table.as_deref(),
source_query.as_deref(),
&dest,
format.as_deref(),
partition_by.as_deref(),
),
}
}
pub fn query(&mut self, pager: &mut Pager, stmt: Statement) -> Result<Vec<Row>> {
if Self::is_mutation(&stmt) {
self.atomic_statement(pager, |executor, pager| executor.query_inner(pager, stmt))
} else {
self.query_inner(pager, stmt)
}
}
fn query_inner(&mut self, pager: &mut Pager, stmt: Statement) -> Result<Vec<Row>> {
match stmt {
Statement::InsertMany {
table,
columns,
rows,
conflict_action,
returning,
} => {
let mut returned = Vec::new();
for values in rows {
let (_, result) = self.execute_insert(
pager,
table.clone(),
columns.clone(),
values,
conflict_action.clone(),
returning.clone(),
)?;
returned.extend(result);
}
Ok(returned)
}
Statement::Insert {
table,
columns,
values,
conflict_action,
returning,
} => {
let (_, rows) =
self.execute_insert(pager, table, columns, values, conflict_action, returning)?;
Ok(rows)
}
Statement::Update {
table,
assignments,
where_clause,
returning,
} => {
let (_, rows) =
self.execute_update(pager, table, assignments, where_clause, returning)?;
Ok(rows)
}
Statement::Delete {
table,
where_clause,
returning,
} => {
let (_, rows) = self.execute_delete(pager, table, where_clause, returning)?;
Ok(rows)
}
Statement::WithCte { ctes, main_query } => {
self.query_with_cte(pager, ctes, *main_query)
}
Statement::Compound { left, op, right } => {
let mut left_rows = self.query(pager, *left)?;
let right_rows = self.query(pager, *right)?;
combine_compound_rows(&mut left_rows, right_rows, op);
Ok(left_rows)
}
Statement::ExternalScan { func, path, arg } => {
#[cfg(feature = "std")]
{
crate::lakehouse::scan_external_rows(&func, &path, arg.as_deref(), None)
}
#[cfg(not(feature = "std"))]
{
let _ = (func, path, arg);
Err(Error::SqlSyntax(
"External file scans require the 'std' feature".into(),
))
}
}
Statement::CopyFrom {
table,
source,
format,
options,
} => {
let count =
self.execute_copy_from(pager, &table, &source, format.as_deref(), &options)?;
Ok(vec![Row::new(
vec!["rows_copied".to_string()],
vec![Value::Integer(count as i64)],
)])
}
Statement::CopyTo {
source_table,
source_query,
dest,
format,
partition_by,
} => {
let count = self.execute_copy_to(
pager,
source_table.as_deref(),
source_query.as_deref(),
&dest,
format.as_deref(),
partition_by.as_deref(),
)?;
Ok(vec![Row::new(
vec!["rows_exported".to_string()],
vec![Value::Integer(count as i64)],
)])
}
Statement::Explain {
statement,
query_plan,
} => self.explain_query_plan(pager, *statement, query_plan),
Statement::Select {
distinct,
columns,
table,
from_subquery,
join,
where_clause,
group_by,
having,
order_by,
limit,
offset,
as_of_timestamp,
} => {
if table.is_empty() {
return Ok(vec![
self.project_row(&Row::new(Vec::new(), Vec::new()), &columns)?,
]);
}
if let Some((sub_stmt, alias)) = from_subquery {
let mut cte_store = HashMap::new();
let sub_rows = self.query(pager, *sub_stmt)?;
cte_store.insert(alias.clone(), sub_rows);
let outer_stmt = Statement::Select {
distinct,
columns,
table: alias,
from_subquery: None,
join,
where_clause,
group_by,
having,
order_by,
limit,
offset,
as_of_timestamp,
};
return self.query_on_ephemeral_rows(pager, outer_stmt, &cte_store);
}
if let Some(view_def) = self.catalog.get_view(&table).cloned() {
let mut view_stmt = crate::sql::parse_sql(&view_def.query_sql)?;
if let Statement::Select {
as_of_timestamp: ref mut view_ts,
..
} = view_stmt
{
*view_ts = as_of_timestamp;
}
let mut rows = self.query(pager, view_stmt)?;
if let Some(ref expr) = where_clause {
let resolved_where = self.resolve_where_expr(pager, expr)?;
rows.retain(|r| row_matches_resolved(r, &resolved_where));
}
if let Some(ref order) = order_by {
rows.sort_by(|a, b| {
let val_a = a.get_value(&order.column).unwrap_or(&Value::Null);
let val_b = b.get_value(&order.column).unwrap_or(&Value::Null);
if order.is_ascending {
val_a.compare(val_b)
} else {
val_b.compare(val_a)
}
});
}
let output_col_names = if columns.is_empty() {
if let Some(first) = rows.first() {
first.columns().to_vec()
} else {
Vec::new()
}
} else {
columns.clone()
};
let mut result_rows = Vec::new();
let skip_count = offset.unwrap_or(0);
let mut skipped = 0;
for row in rows {
let projected = self.project_row(&row, &output_col_names)?;
if distinct && result_rows.contains(&projected) {
continue;
}
if skipped < skip_count {
skipped += 1;
continue;
}
result_rows.push(projected);
if let Some(lim) = limit
&& result_rows.len() >= lim
{
break;
}
}
return Ok(result_rows);
}
let table_def = self
.catalog
.get_table(&table)
.cloned()
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
let root_page = table_def.root_page;
let all_col_names = table_def.column_names();
let fts_query = if table_def.fts_config.is_some() {
where_clause
.as_ref()
.and_then(|e| extract_fts_match_query(e, &table))
} else {
None
};
let fts_scores: Option<HashMap<u64, f64>> = if let Some(ref q) = fts_query {
self.ensure_fts_index(pager, &table_def)?;
let idx_key = table.to_lowercase();
let mut score_map = HashMap::new();
if let Some(idx) = self.fts_indexes.get(&idx_key) {
let total_docs = idx.total_docs().max(1);
for (doc_id, score) in idx.search(q, total_docs) {
score_map.insert(doc_id, -(score as f64));
}
}
Some(score_map)
} else {
None
};
let resolved_where = if let Some(ref expr) = where_clause {
Some(self.resolve_where_expr(pager, expr)?)
} else {
None
};
let resolved_having = if let Some(ref h_expr) = having {
Some(self.resolve_where_expr(pager, h_expr)?)
} else {
None
};
let pk_idx = table_def.primary_key_index();
if as_of_timestamp.is_none()
&& join.is_none()
&& order_by.is_none()
&& group_by.is_none()
&& let (Some(pk_col_idx), Some(WhereExpr::Condition(cond))) =
(pk_idx, &where_clause)
&& cond.op == BinaryOp::Equals
{
let pk_name = &table_def.columns[pk_col_idx].name;
if pk_name.eq_ignore_ascii_case(&cond.column)
&& let Value::Integer(target_key) = cond.value
{
if offset.unwrap_or(0) > 0 || limit == Some(0) {
return Ok(Vec::new());
}
if let Some(payload) =
self.btree.search(pager, root_page, target_key as u64)?
{
let full_row = decode_row(&payload, &all_col_names)?;
let output_col_names = if columns.is_empty() {
all_col_names.clone()
} else {
columns.clone()
};
let projected = self.project_row(&full_row, &output_col_names)?;
return Ok(vec![projected]);
} else {
return Ok(Vec::new());
}
}
}
if as_of_timestamp.is_none()
&& join.is_none()
&& order_by.is_none()
&& group_by.is_none()
&& let Some(ref expr) = where_clause
{
let mut and_eqs = HashMap::new();
collect_and_eq_conditions(expr, &mut and_eqs);
if and_eqs.len() >= 2 {
let matched_comp_idx = self
.catalog
.indexes()
.into_iter()
.filter(|idx| {
idx.table.eq_ignore_ascii_case(&table)
&& partial_index_matches_query(idx, where_clause.as_ref())
})
.filter_map(|idx| {
let cols = idx.target_columns();
if cols.len() >= 2
&& cols.iter().all(|c| and_eqs.contains_key(&c.to_lowercase()))
{
Some((cols.len(), idx))
} else {
None
}
})
.max_by_key(|(len, _)| *len)
.map(|(_, idx)| idx);
if let Some(index_def) = matched_comp_idx {
let tcols = index_def.target_columns();
let dummy_cols: Vec<String> =
tcols.iter().map(|c| (*c).to_string()).collect();
let dummy_vals: Vec<Value> = tcols
.iter()
.map(|c| {
and_eqs
.get(&c.to_lowercase())
.cloned()
.unwrap_or(Value::Null)
})
.collect();
let dummy_row = Row::new(dummy_cols, dummy_vals);
if let Some((comp_val, _)) = extract_index_key_value(&dummy_row, &tcols)
{
let key = value_to_index_key(&comp_val);
let mut matched_row_ids = Vec::new();
if let Some(payload) =
self.btree.search(pager, index_def.root_page, key)?
&& let Ok(bucket) =
serde_json::from_slice::<IndexBucket>(&payload)
&& let Some(rids) = bucket.get_row_ids(&comp_val)
{
matched_row_ids.extend_from_slice(rids);
}
let output_col_names = if columns.is_empty() {
all_col_names.clone()
} else {
columns.clone()
};
let mut result_rows = Vec::new();
let skip_count = offset.unwrap_or(0);
let mut skipped = 0;
for rid in matched_row_ids {
if let Some(payload) =
self.btree.search(pager, root_page, rid)?
{
let full_row = decode_row(&payload, &all_col_names)?;
if let Some(ref r_expr) = resolved_where
&& !row_matches_resolved(&full_row, r_expr)
{
continue;
}
let projected =
self.project_row(&full_row, &output_col_names)?;
if distinct && result_rows.contains(&projected) {
continue;
}
if skipped < skip_count {
skipped += 1;
continue;
}
result_rows.push(projected);
if let Some(lim) = limit
&& result_rows.len() >= lim
{
break;
}
}
}
return Ok(result_rows);
}
}
}
}
if as_of_timestamp.is_none()
&& join.is_none()
&& order_by.is_none()
&& group_by.is_none()
&& let Some(ref w_expr) = where_clause
{
let mut eq_conds = HashMap::new();
collect_and_eq_conditions(w_expr, &mut eq_conds);
let chosen_single = eq_conds.iter().find_map(|(col_key, val)| {
self.find_usable_index_for_column(&table, col_key, Some(w_expr))
.map(|idx| (col_key.clone(), val.clone(), idx))
});
if let Some((cond_col, cond_val, index_def)) = chosen_single {
let optimizer = crate::sql::planner::CostOptimizer::new();
let default_stats = crate::sql::planner::TableStats::new(&table, 100, 10);
let stats = self
.catalog
.get_table_stats(&table)
.unwrap_or(&default_stats);
let sel = stats.estimate_selectivity(&cond_col, true);
let index_cost =
optimizer.estimate_index_scan(stats, &index_def.name, &cond_col, sel);
let seq_cost = optimizer.estimate_seq_scan(stats, sel);
if index_cost.total_cost <= seq_cost.total_cost {
let key = value_to_index_key(&cond_val);
let mut matched_row_ids = Vec::new();
if let Some(payload) =
self.btree.search(pager, index_def.root_page, key)?
&& let Ok(bucket) = serde_json::from_slice::<IndexBucket>(&payload)
&& let Some(rids) = bucket.get_row_ids(&cond_val)
{
matched_row_ids.extend_from_slice(rids);
}
let output_col_names = if columns.is_empty() {
all_col_names.clone()
} else {
columns.clone()
};
let mut result_rows = Vec::new();
let skip_count = offset.unwrap_or(0);
let mut skipped = 0;
for rid in matched_row_ids {
if let Some(payload) = self.btree.search(pager, root_page, rid)? {
let full_row = decode_row(&payload, &all_col_names)?;
if let Some(ref r_expr) = resolved_where
&& !row_matches_resolved(&full_row, r_expr)
{
continue;
}
let projected =
self.project_row(&full_row, &output_col_names)?;
if distinct && result_rows.contains(&projected) {
continue;
}
if skipped < skip_count {
skipped += 1;
continue;
}
result_rows.push(projected);
if let Some(lim) = limit
&& result_rows.len() >= lim
{
break;
}
}
}
return Ok(result_rows);
}
}
}
if join.is_none()
&& order_by.is_none()
&& group_by.is_none()
&& as_of_timestamp.is_none()
&& !distinct
&& is_aggregate_query(&columns)
{
struct PushdownAgg {
spec: ParsedAggSpec,
col_idx: Option<usize>,
acc: crate::sql::vectorized::VectorizedAccumulator,
}
let mut aggs: Vec<PushdownAgg> = Vec::new();
for col in &columns {
if let Some(spec) = parse_aggregate_spec(col) {
let col_idx = if spec.is_star {
None
} else {
table_def.column_index(&spec.arg)
};
let acc = crate::sql::vectorized::VectorizedAccumulator::with_tracking(
spec.needs_samples(),
spec.needs_distinct(),
);
aggs.push(PushdownAgg { spec, col_idx, acc });
} else {
let output_name = parse_col_and_alias(col).1.unwrap_or(col).to_string();
aggs.push(PushdownAgg {
spec: ParsedAggSpec {
output_name,
func: String::new(),
arg: String::new(),
percentile_q: None,
is_star: false,
is_distinct: false,
},
col_idx: table_def.column_index(col),
acc: crate::sql::vectorized::VectorizedAccumulator::new(),
});
}
}
let mut needed_mask = vec![false; all_col_names.len()];
for agg in &aggs {
if let Some(idx) = agg.col_idx
&& idx < needed_mask.len()
{
needed_mask[idx] = true;
}
}
let mut row_vals = Vec::with_capacity(all_col_names.len());
self.btree
.scan_with_ref(pager, root_page, |_row_id, payload| {
if let Some(ref r_expr) = resolved_where {
let full_row = decode_row(payload, &all_col_names)?;
if !row_matches_resolved(&full_row, r_expr) {
return Ok(true);
}
for agg in &mut aggs {
if agg.spec.is_star {
agg.acc.count_all += 1;
agg.acc.count += 1;
} else if let Some(idx) = agg.col_idx
&& let Some(val) = full_row.values().get(idx)
{
agg.acc.accumulate_value(val);
}
}
} else {
decode_row_values_into_projected(
payload,
&needed_mask,
&mut row_vals,
)?;
for agg in &mut aggs {
if agg.spec.is_star {
agg.acc.count_all += 1;
agg.acc.count += 1;
} else if let Some(idx) = agg.col_idx
&& let Some(val) = row_vals.get(idx)
{
agg.acc.accumulate_value(val);
}
}
}
Ok(true)
})?;
let mut out_cols = Vec::with_capacity(aggs.len());
let mut out_vals = Vec::with_capacity(aggs.len());
for mut agg in aggs {
let out_name = agg.spec.output_name.clone();
let val = agg.spec.finalize(&mut agg.acc);
out_cols.push(out_name);
out_vals.push(val);
}
return Ok(vec![Row::new(out_cols, out_vals)]);
}
if let Some(ref gb_cols) = group_by
&& join.is_none()
&& as_of_timestamp.is_none()
&& fts_scores.is_none()
&& !columns.iter().any(|c| has_window_function(c))
{
let resolved_having = if let Some(ref h) = having {
Some(self.resolve_where_expr(pager, h)?)
} else {
None
};
let output_cols = if columns.is_empty() {
gb_cols.clone()
} else {
columns.clone()
};
enum GroupColPlan {
GroupKey {
out_name: String,
key_pos: usize,
},
Aggregate {
spec: ParsedAggSpec,
},
FirstValue {
out_name: String,
col_idx: Option<usize>,
},
}
let gb_indices: Vec<Option<usize>> =
gb_cols.iter().map(|c| table_def.column_index(c)).collect();
let mut plans = Vec::with_capacity(output_cols.len());
let mut agg_specs_template: Vec<(Option<usize>, bool, bool, bool)> = Vec::new();
let mut needed_mask = vec![false; all_col_names.len()];
for idx_opt in &gb_indices {
if let Some(i) = *idx_opt
&& i < needed_mask.len()
{
needed_mask[i] = true;
}
}
for col in &output_cols {
if let Some(spec) = parse_aggregate_spec(col) {
let col_idx = if spec.is_star {
None
} else {
table_def.column_index(&spec.arg)
};
if let Some(i) = col_idx
&& i < needed_mask.len()
{
needed_mask[i] = true;
}
agg_specs_template.push((
col_idx,
spec.is_star,
spec.needs_samples(),
spec.needs_distinct(),
));
plans.push(GroupColPlan::Aggregate { spec });
} else {
let (raw_expr, alias_opt) = parse_col_and_alias(col);
let out_name = alias_opt.unwrap_or(raw_expr).to_string();
if let Some(pos) = gb_cols
.iter()
.position(|g| g.eq_ignore_ascii_case(raw_expr))
{
plans.push(GroupColPlan::GroupKey {
out_name,
key_pos: pos,
});
} else {
let col_idx = table_def.column_index(raw_expr);
if let Some(i) = col_idx
&& i < needed_mask.len()
{
needed_mask[i] = true;
}
plans.push(GroupColPlan::FirstValue { out_name, col_idx });
}
}
}
struct StreamGroupState {
keys: Vec<Value>,
accs: Vec<crate::sql::vectorized::VectorizedAccumulator>,
first_vals: Vec<(usize, Value)>,
}
let mut group_map: HashMap<Vec<HashableValue>, usize> = HashMap::new();
let mut groups: Vec<StreamGroupState> = Vec::new();
let mut row_vals = Vec::with_capacity(all_col_names.len());
let mut hash_key_buf: Vec<HashableValue> = Vec::with_capacity(gb_cols.len());
self.btree
.scan_with_ref(pager, root_page, |_row_id, payload| {
if let Some(ref r_expr) = resolved_where {
let full_row = decode_row(payload, &all_col_names)?;
if !row_matches_resolved(&full_row, r_expr) {
return Ok(true);
}
let vals = full_row.values();
hash_key_buf.clear();
for idx_opt in &gb_indices {
let v = idx_opt
.and_then(|i| vals.get(i))
.unwrap_or(&Value::Null);
hash_key_buf.push(HashableValue::from(v));
}
let g_pos = if let Some(&pos) = group_map.get(&hash_key_buf) {
pos
} else {
let pos = groups.len();
let key_vals: Vec<Value> = gb_indices
.iter()
.map(|idx_opt| {
idx_opt
.and_then(|i| vals.get(i).cloned())
.unwrap_or(Value::Null)
})
.collect();
let accs = agg_specs_template
.iter()
.map(|&(_, _, s, d)| {
crate::sql::vectorized::VectorizedAccumulator::with_tracking(s, d)
})
.collect();
let mut fv = Vec::new();
for p in &plans {
if let GroupColPlan::FirstValue { col_idx: Some(ci), .. } = p {
fv.push((
*ci,
vals.get(*ci).cloned().unwrap_or(Value::Null),
));
}
}
group_map.insert(hash_key_buf.clone(), pos);
groups.push(StreamGroupState {
keys: key_vals,
accs,
first_vals: fv,
});
pos
};
let state = &mut groups[g_pos];
for (acc_idx, &(col_idx, is_star, _, _)) in
agg_specs_template.iter().enumerate()
{
if is_star {
state.accs[acc_idx].count_all += 1;
state.accs[acc_idx].count += 1;
} else if let Some(ci) = col_idx
&& let Some(v) = vals.get(ci)
{
state.accs[acc_idx].accumulate_value(v);
}
}
} else {
decode_row_values_into_projected(
payload,
&needed_mask,
&mut row_vals,
)?;
hash_key_buf.clear();
for idx_opt in &gb_indices {
let v = idx_opt
.and_then(|i| row_vals.get(i))
.unwrap_or(&Value::Null);
hash_key_buf.push(HashableValue::from(v));
}
let g_pos = if let Some(&pos) = group_map.get(&hash_key_buf) {
pos
} else {
let pos = groups.len();
let key_vals: Vec<Value> = gb_indices
.iter()
.map(|idx_opt| {
idx_opt
.and_then(|i| row_vals.get(i).cloned())
.unwrap_or(Value::Null)
})
.collect();
let accs = agg_specs_template
.iter()
.map(|&(_, _, s, d)| {
crate::sql::vectorized::VectorizedAccumulator::with_tracking(s, d)
})
.collect();
let mut fv = Vec::new();
for p in &plans {
if let GroupColPlan::FirstValue { col_idx: Some(ci), .. } = p {
fv.push((
*ci,
row_vals.get(*ci).cloned().unwrap_or(Value::Null),
));
}
}
group_map.insert(hash_key_buf.clone(), pos);
groups.push(StreamGroupState {
keys: key_vals,
accs,
first_vals: fv,
});
pos
};
let state = &mut groups[g_pos];
for (acc_idx, &(col_idx, is_star, _, _)) in
agg_specs_template.iter().enumerate()
{
if is_star {
state.accs[acc_idx].count_all += 1;
state.accs[acc_idx].count += 1;
} else if let Some(ci) = col_idx
&& let Some(v) = row_vals.get(ci)
{
state.accs[acc_idx].accumulate_value(v);
}
}
}
Ok(true)
})?;
let mut result_rows = Vec::with_capacity(groups.len());
for mut state in groups {
let mut g_cols = Vec::with_capacity(plans.len());
let mut g_vals = Vec::with_capacity(plans.len());
let mut acc_cursor = 0usize;
for plan in &plans {
match plan {
GroupColPlan::GroupKey { out_name, key_pos } => {
g_cols.push(out_name.clone());
g_vals.push(state.keys[*key_pos].clone());
}
GroupColPlan::Aggregate { spec } => {
g_cols.push(spec.output_name.clone());
g_vals.push(spec.finalize(&mut state.accs[acc_cursor]));
acc_cursor += 1;
}
GroupColPlan::FirstValue { out_name, col_idx } => {
g_cols.push(out_name.clone());
let v = col_idx
.and_then(|ci| {
state
.first_vals
.iter()
.find(|(i, _)| *i == ci)
.map(|(_, val)| val.clone())
})
.unwrap_or(Value::Null);
g_vals.push(v);
}
}
}
let row = Row::new(g_cols, g_vals);
if let Some(ref h_expr) = resolved_having
&& !row_matches_resolved(&row, h_expr)
{
continue;
}
result_rows.push(row);
}
if let Some(order) = order_by {
result_rows.sort_by(|a, b| {
let val_a = a.get_value(&order.column).unwrap_or(&Value::Null);
let val_b = b.get_value(&order.column).unwrap_or(&Value::Null);
if order.is_ascending {
val_a.compare(val_b)
} else {
val_b.compare(val_a)
}
});
}
if distinct {
let mut seen = HashSet::new();
result_rows.retain(|r| seen.insert(format!("{:?}", r.values())));
}
if let Some(off) = offset {
if off < result_rows.len() {
result_rows = result_rows.split_off(off);
} else {
result_rows.clear();
}
}
if let Some(lim) = limit {
result_rows.truncate(lim);
}
return Ok(result_rows);
}
let mut left_rows = Vec::new();
if let Some(ts) = as_of_timestamp {
let is_versioned =
table_def.system_versioning || self.default_system_versioning;
if !is_versioned && self.catalog.get_table("__sys_time_travel").is_none() {
return Err(Error::SqlSyntax(format!(
"Table '{}' does not have SYSTEM_VERSIONING enabled. Enable with PRAGMA time_travel = ON or CREATE TABLE ... WITH (SYSTEM_VERSIONING = TRUE)",
table
)));
}
if let Some(sys_table) = self.catalog.get_table("__sys_time_travel") {
let cells = self.btree.scan(pager, sys_table.root_page)?;
for cell in cells {
if let Ok(rec) = serde_json::from_slice::<TemporalRecord>(&cell.payload)
&& rec.table_name.eq_ignore_ascii_case(&table)
&& rec.valid_from <= ts
&& rec.valid_to > ts
{
let full_row = decode_row(&rec.payload, &all_col_names)?;
if let Some(ref r_expr) = resolved_where
&& !row_matches_resolved(&full_row, r_expr)
{
continue;
}
left_rows.push(full_row);
}
}
}
}
let (direct_join_sources, left_needed_mask) = if let Some(ref jc) = join {
if let Some(right_table_def) = self.catalog.get_table(&jc.table) {
let can_direct = order_by.is_none()
&& group_by.is_none()
&& !distinct
&& !is_aggregate_query(&columns)
&& !columns.is_empty();
if can_direct {
let mut sources = Vec::with_capacity(columns.len());
let mut ok = true;
for col in &columns {
if col.contains('(') || col.contains(' ') {
ok = false;
break;
}
if let Some((tbl, c)) = col.split_once('.') {
if tbl.eq_ignore_ascii_case(&table) {
if let Some(idx) = table_def.column_index(c) {
sources.push(JoinOutputCol::Left(idx));
continue;
}
} else if tbl.eq_ignore_ascii_case(&jc.table)
&& let Some(idx) = right_table_def.column_index(c)
{
sources.push(JoinOutputCol::Right(idx));
continue;
}
ok = false;
break;
} else {
let in_l = table_def.column_index(col);
let in_r = right_table_def.column_index(col);
match (in_l, in_r) {
(Some(idx), None) => sources.push(JoinOutputCol::Left(idx)),
(None, Some(idx)) => {
sources.push(JoinOutputCol::Right(idx))
}
_ => {
ok = false;
break;
}
}
}
}
if ok {
let mut mask = vec![false; all_col_names.len()];
if let Some(l_idx) =
resolve_table_col_index(&table_def, &jc.left_col)
&& l_idx < mask.len()
{
mask[l_idx] = true;
}
for src in &sources {
if let JoinOutputCol::Left(idx) = src
&& *idx < mask.len()
{
mask[*idx] = true;
}
}
(Some(sources), Some(mask))
} else {
(None, None)
}
} else {
(None, None)
}
} else {
(None, None)
}
} else {
(None, None)
};
if let (Some(jc), Some(sources)) = (join.as_ref(), direct_join_sources.as_ref())
&& as_of_timestamp.is_none()
&& where_clause.is_none()
&& jc.join_type == JoinType::Inner
&& let Some(right_table_def) = self.catalog.get_table(&jc.table)
{
let l_col_idx = resolve_table_col_index(&table_def, &jc.left_col);
let r_col_idx = resolve_table_col_index(right_table_def, &jc.right_col);
if let (Some(l_idx), Some(r_idx)) = (l_col_idx, r_col_idx) {
let output_col_shared = Arc::new(columns.clone());
let left_col_shared = Arc::new(all_col_names.clone());
let right_col_names = right_table_def.column_names();
let right_col_shared = Arc::new(right_col_names.clone());
let skip_count = offset.unwrap_or(0);
if table_def.primary_key_index() == Some(l_idx) {
let mut right_mask = vec![false; right_col_names.len()];
right_mask[r_idx] = true;
for src in sources {
if let JoinOutputCol::Right(idx) = src
&& *idx < right_mask.len()
{
right_mask[*idx] = true;
}
}
let mut driving_tuples: Vec<(i64, Row)> = Vec::new();
self.btree
.scan_with(pager, right_table_def.root_page, |r_cell| {
let r_row = decode_row_shared_projected(
&r_cell.payload,
&right_col_shared,
&right_mask,
)?;
if let Some(Value::Integer(k)) = r_row.values().get(r_idx) {
driving_tuples.push((*k, r_row));
}
Ok(true)
})?;
let left_mask = left_needed_mask.as_deref().unwrap_or(&[]);
let mut final_rows = Vec::with_capacity(
driving_tuples.len().min(limit.unwrap_or(usize::MAX)),
);
let mut skipped = 0;
for (k, r_row) in driving_tuples {
if let Some(l_payload) =
self.btree.search(pager, root_page, k as u64)?
{
if skipped < skip_count {
skipped += 1;
continue;
}
let l_row = decode_row_shared_projected(
&l_payload,
&left_col_shared,
left_mask,
)?;
let mut vals = Vec::with_capacity(sources.len());
for src in sources {
match src {
JoinOutputCol::Left(idx) => vals.push(
l_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
),
JoinOutputCol::Right(idx) => vals.push(
r_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
),
}
}
final_rows.push(Row::with_shared_columns(
output_col_shared.clone(),
vals,
));
if let Some(lim) = limit
&& final_rows.len() >= lim
{
break;
}
}
}
return Ok(final_rows);
}
if right_table_def.primary_key_index() == Some(r_idx) {
let left_mask = left_needed_mask.as_deref().unwrap_or(&[]);
let mut driving_tuples: Vec<(i64, Row)> = Vec::new();
self.btree.scan_with(pager, root_page, |l_cell| {
let l_row = decode_row_shared_projected(
&l_cell.payload,
&left_col_shared,
left_mask,
)?;
if let Some(Value::Integer(k)) = l_row.values().get(l_idx) {
driving_tuples.push((*k, l_row));
}
Ok(true)
})?;
let mut right_mask = vec![false; right_col_names.len()];
right_mask[r_idx] = true;
for src in sources {
if let JoinOutputCol::Right(idx) = src
&& *idx < right_mask.len()
{
right_mask[*idx] = true;
}
}
let mut final_rows = Vec::with_capacity(
driving_tuples.len().min(limit.unwrap_or(usize::MAX)),
);
let mut skipped = 0;
for (k, l_row) in driving_tuples {
if let Some(r_payload) =
self.btree
.search(pager, right_table_def.root_page, k as u64)?
{
if skipped < skip_count {
skipped += 1;
continue;
}
let r_row = decode_row_shared_projected(
&r_payload,
&right_col_shared,
&right_mask,
)?;
let mut vals = Vec::with_capacity(sources.len());
for src in sources {
match src {
JoinOutputCol::Left(idx) => vals.push(
l_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
),
JoinOutputCol::Right(idx) => vals.push(
r_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
),
}
}
final_rows.push(Row::with_shared_columns(
output_col_shared.clone(),
vals,
));
if let Some(lim) = limit
&& final_rows.len() >= lim
{
break;
}
}
}
return Ok(final_rows);
}
}
}
let wants_fts_scores = fts_scores.is_some()
&& (columns.iter().any(|c| {
let cl = c.to_ascii_lowercase();
cl == "rank" || cl.starts_with("bm25(")
}) || order_by.as_ref().is_some_and(|o| {
let ol = o.column.to_ascii_lowercase();
ol == "rank" || ol.starts_with("bm25(")
}));
let mut fts_left_col_shared: Option<Arc<Vec<String>>> = None;
if as_of_timestamp.is_none() {
let can_early_terminate = join.is_none()
&& order_by.is_none()
&& group_by.is_none()
&& !distinct
&& !is_aggregate_query(&columns);
let needed_rows = if can_early_terminate {
limit.map(|lim| offset.unwrap_or(0).saturating_add(lim))
} else {
None
};
let left_col_shared = Arc::new(all_col_names.clone());
if wants_fts_scores {
let mut extended = all_col_names.clone();
extended.push("rank".to_string());
extended.push(format!("bm25({table})"));
fts_left_col_shared = Some(Arc::new(extended));
}
self.btree.scan_with(pager, root_page, |cell| {
let mut full_row = if let Some(ref mask) = left_needed_mask {
decode_row_shared_projected(&cell.payload, &left_col_shared, mask)?
} else {
decode_row_shared(&cell.payload, &left_col_shared)?
};
if let Some(ref r_expr) = resolved_where {
if let Some(ref scores) = fts_scores {
let eff_expr = resolve_fts_match_predicate(
r_expr,
&table,
scores.contains_key(&cell.row_id),
);
if !row_matches_resolved(&full_row, &eff_expr) {
return Ok(true);
}
} else if !row_matches_resolved(&full_row, r_expr) {
return Ok(true);
}
}
if let (Some(scores), Some(ext_cols)) =
(fts_scores.as_ref(), fts_left_col_shared.as_ref())
{
let rank_val = scores.get(&cell.row_id).copied().unwrap_or(0.0);
let mut vals = full_row.values().to_vec();
vals.push(Value::Real(rank_val));
vals.push(Value::Real(rank_val));
full_row = Row::with_shared_columns(ext_cols.clone(), vals);
}
left_rows.push(full_row);
if let Some(needed) = needed_rows
&& left_rows.len() >= needed
{
return Ok(false);
}
Ok(true)
})?;
}
if let Some(join_clause) = join {
let right_table_def = self
.catalog
.get_table(&join_clause.table)
.ok_or_else(|| Error::TableNotFound(join_clause.table.clone()))?;
let right_col_names = right_table_def.column_names();
let right_col_shared = Arc::new(right_col_names.clone());
let mut merged_cols_template =
Vec::with_capacity(all_col_names.len() + right_col_names.len());
for c in &all_col_names {
merged_cols_template.push(format!("{}.{}", table, c));
}
for c in &right_col_names {
merged_cols_template.push(format!("{}.{}", join_clause.table, c));
}
let merged_cols_shared = Arc::new(merged_cols_template);
let l_col_idx = resolve_table_col_index(&table_def, &join_clause.left_col);
let r_col_idx =
resolve_table_col_index(right_table_def, &join_clause.right_col);
let mut right_rows = Vec::new();
if let Some(ts) = as_of_timestamp {
if let Some(sys_table) = self.catalog.get_table("__sys_time_travel") {
self.btree.scan_with(pager, sys_table.root_page, |cell| {
if let Ok(rec) =
serde_json::from_slice::<TemporalRecord>(&cell.payload)
&& rec.table_name.eq_ignore_ascii_case(&join_clause.table)
&& rec.valid_from <= ts
&& rec.valid_to > ts
{
let r_row = decode_row_shared(&rec.payload, &right_col_shared)?;
right_rows.push(r_row);
}
Ok(true)
})?;
}
} else {
let right_mask = if let Some(ref sources) = direct_join_sources {
let mut mask = vec![false; right_col_names.len()];
if let Some(r_idx) = r_col_idx
&& r_idx < mask.len()
{
mask[r_idx] = true;
}
for src in sources {
if let JoinOutputCol::Right(idx) = src
&& *idx < mask.len()
{
mask[*idx] = true;
}
}
Some(mask)
} else {
None
};
self.btree
.scan_with(pager, right_table_def.root_page, |r_cell| {
let r_row = if let Some(ref mask) = right_mask {
decode_row_shared_projected(
&r_cell.payload,
&right_col_shared,
mask,
)?
} else {
decode_row_shared(&r_cell.payload, &right_col_shared)?
};
right_rows.push(r_row);
Ok(true)
})?;
}
let all_int_keys = r_col_idx.is_some_and(|idx| {
right_rows
.first()
.and_then(|r| r.values().get(idx))
.is_some_and(|v| matches!(v, Value::Integer(_)))
}) && l_col_idx.is_some_and(|idx| {
left_rows
.first()
.and_then(|l| l.values().get(idx))
.is_some_and(|v| matches!(v, Value::Integer(_)))
});
let is_right_or_full = join_clause.join_type == JoinType::Right
|| join_clause.join_type == JoinType::Full;
let mut joined_rows = Vec::with_capacity(left_rows.len());
if all_int_keys && !is_right_or_full {
let r_idx_col = r_col_idx.unwrap();
let l_idx_col = l_col_idx.unwrap();
let mut int_hash: HashMap<i64, IntEntry, FastIntBuildHasher> =
HashMap::with_capacity_and_hasher(
right_rows.len(),
FastIntBuildHasher::default(),
);
for (r_idx, r_row) in right_rows.iter().enumerate() {
if let Some(Value::Integer(k)) = r_row.values().get(r_idx_col) {
match int_hash.get_mut(k) {
Some(IntEntry::One(prev)) => {
let first = *prev;
int_hash.insert(*k, IntEntry::Many(vec![first, r_idx]));
}
Some(IntEntry::Many(list)) => {
list.push(r_idx);
}
None => {
int_hash.insert(*k, IntEntry::One(r_idx));
}
}
}
}
if let Some(ref direct_sources) = direct_join_sources {
let output_col_shared = Arc::new(columns.clone());
let mut final_rows =
Vec::with_capacity(left_rows.len().min(right_rows.len() * 2));
for l_row in &left_rows {
let mut matched = false;
if let Some(Value::Integer(lk)) = l_row.values().get(l_idx_col)
&& let Some(entry) = int_hash.get(lk)
{
matched = true;
let r_slice = match entry {
IntEntry::One(idx) => std::slice::from_ref(idx),
IntEntry::Many(v) => v.as_slice(),
};
for &r_idx in r_slice {
let r_row = &right_rows[r_idx];
let mut vals = Vec::with_capacity(direct_sources.len());
for src in direct_sources {
match src {
JoinOutputCol::Left(idx) => {
vals.push(
l_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
);
}
JoinOutputCol::Right(idx) => {
vals.push(
r_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
);
}
}
}
final_rows.push(Row::with_shared_columns(
output_col_shared.clone(),
vals,
));
}
}
if !matched
&& (join_clause.join_type == JoinType::Left
|| join_clause.is_left)
{
let mut vals = Vec::with_capacity(direct_sources.len());
for src in direct_sources {
match src {
JoinOutputCol::Left(idx) => {
vals.push(
l_row
.values()
.get(*idx)
.cloned()
.unwrap_or(Value::Null),
);
}
JoinOutputCol::Right(_) => {
vals.push(Value::Null);
}
}
}
final_rows.push(Row::with_shared_columns(
output_col_shared.clone(),
vals,
));
}
}
let skip_count = offset.unwrap_or(0);
if skip_count > 0 || limit.is_some() {
let mut sliced = Vec::new();
let mut skipped = 0;
for r in final_rows {
if skipped < skip_count {
skipped += 1;
continue;
}
sliced.push(r);
if let Some(lim) = limit
&& sliced.len() >= lim
{
break;
}
}
return Ok(sliced);
}
return Ok(final_rows);
}
for l_row in &left_rows {
let mut matched = false;
if let Some(Value::Integer(lk)) = l_row.values().get(l_idx_col)
&& let Some(entry) = int_hash.get(lk)
{
matched = true;
let r_slice = match entry {
IntEntry::One(idx) => std::slice::from_ref(idx),
IntEntry::Many(v) => v.as_slice(),
};
for &r_idx in r_slice {
let r_row = &right_rows[r_idx];
let mut merged_vals = Vec::with_capacity(
l_row.values().len() + r_row.values().len(),
);
merged_vals.extend_from_slice(l_row.values());
merged_vals.extend_from_slice(r_row.values());
joined_rows.push(Row::with_shared_columns(
merged_cols_shared.clone(),
merged_vals,
));
}
}
if !matched
&& (join_clause.join_type == JoinType::Left || join_clause.is_left)
{
let mut merged_vals = Vec::with_capacity(
l_row.values().len() + right_table_def.columns.len(),
);
merged_vals.extend_from_slice(l_row.values());
for _ in 0..right_table_def.columns.len() {
merged_vals.push(Value::Null);
}
joined_rows.push(Row::with_shared_columns(
merged_cols_shared.clone(),
merged_vals,
));
}
}
} else {
let mut right_hash_table: HashMap<HashableValue, Vec<usize>> =
HashMap::with_capacity(right_rows.len());
for (r_idx, r_row) in right_rows.iter().enumerate() {
let r_val = if let Some(idx) = r_col_idx {
r_row.values().get(idx)
} else {
r_row.get_value(&join_clause.right_col)
};
if let Some(r_val) = r_val
&& !r_val.is_null()
{
right_hash_table
.entry(HashableValue::from(r_val))
.or_default()
.push(r_idx);
}
}
let mut matched_right_indices = if is_right_or_full {
HashSet::with_capacity(right_rows.len())
} else {
HashSet::new()
};
for l_row in &left_rows {
let l_val = if let Some(idx) = l_col_idx {
l_row.values().get(idx)
} else {
l_row.get_value(&join_clause.left_col)
};
let mut matched = false;
if let Some(lv) = l_val
&& !lv.is_null()
&& let Some(matching_r_indices) =
right_hash_table.get(&HashableValue::from(lv))
{
matched = true;
for &r_idx in matching_r_indices {
let r_row = &right_rows[r_idx];
if is_right_or_full {
matched_right_indices.insert(r_idx);
}
let mut merged_vals = Vec::with_capacity(
l_row.values().len() + r_row.values().len(),
);
merged_vals.extend_from_slice(l_row.values());
merged_vals.extend_from_slice(r_row.values());
joined_rows.push(Row::with_shared_columns(
merged_cols_shared.clone(),
merged_vals,
));
}
}
if !matched
&& (join_clause.join_type == JoinType::Left
|| join_clause.join_type == JoinType::Full)
{
let mut merged_vals = Vec::with_capacity(
l_row.values().len() + right_col_names.len(),
);
merged_vals.extend_from_slice(l_row.values());
merged_vals
.resize(merged_vals.len() + right_col_names.len(), Value::Null);
joined_rows.push(Row::with_shared_columns(
merged_cols_shared.clone(),
merged_vals,
));
}
}
if is_right_or_full {
for (r_idx, r_row) in right_rows.iter().enumerate() {
if !matched_right_indices.contains(&r_idx) {
let mut merged_vals = Vec::with_capacity(
all_col_names.len() + right_col_names.len(),
);
merged_vals.resize(all_col_names.len(), Value::Null);
merged_vals.extend_from_slice(r_row.values());
joined_rows.push(Row::with_shared_columns(
merged_cols_shared.clone(),
merged_vals,
));
}
}
}
}
left_rows = joined_rows;
}
if let Some(ref gb_cols) = group_by {
left_rows = aggregate_ephemeral_rows(
&left_rows,
&columns,
gb_cols,
resolved_having.as_ref(),
);
} else if is_aggregate_query(&columns) {
let mut agg_cols = Vec::new();
let mut agg_vals = Vec::new();
for col in &columns {
if let Some(spec) = parse_aggregate_spec(col) {
let computed = compute_aggregate_from_spec(&spec, &left_rows);
agg_cols.push(spec.output_name);
agg_vals.push(computed);
} else {
agg_cols.push(parse_col_and_alias(col).1.unwrap_or(col).to_string());
agg_vals.push(Value::Null);
}
}
return Ok(vec![Row::new(agg_cols, agg_vals)]);
}
if columns.iter().any(|c| has_window_function(c)) {
evaluate_window_functions(&mut left_rows, &columns)?;
}
if let Some(order) = order_by {
left_rows.sort_by(|a, b| {
let val_a = a.get_value(&order.column).unwrap_or(&Value::Null);
let val_b = b.get_value(&order.column).unwrap_or(&Value::Null);
if order.is_ascending {
val_a.compare(val_b)
} else {
val_b.compare(val_a)
}
});
}
let output_col_names = if columns.is_empty() {
if wants_fts_scores {
all_col_names.clone()
} else if let Some(first_row) = left_rows.first() {
first_row.columns().to_vec()
} else {
all_col_names.clone()
}
} else {
columns.clone()
};
let output_col_shared = Arc::new(output_col_names);
let mut direct_indices: Option<Vec<usize>> = None;
if let Some(first) = left_rows.first() {
let mut indices = Vec::with_capacity(output_col_shared.len());
let mut all_matched = true;
for col in output_col_shared.iter() {
let col_lower = col.to_ascii_lowercase();
let is_direct_bm25 =
col_lower.starts_with("bm25(") && !col_lower.contains(" as ");
if !is_direct_bm25 && (col.contains('(') || col.contains(' ')) {
all_matched = false;
break;
}
if let Some(pos) = first
.columns()
.iter()
.position(|c| col_name_matches(c, col))
{
indices.push(pos);
} else {
all_matched = false;
break;
}
}
if all_matched {
direct_indices = Some(indices);
}
}
let mut rows = Vec::new();
let skip_count = offset.unwrap_or(0);
let mut skipped = 0;
for row in left_rows {
let projected = if let Some(ref indices) = direct_indices {
let mut vals = Vec::with_capacity(indices.len());
for &idx in indices {
vals.push(row.values().get(idx).cloned().unwrap_or(Value::Null));
}
Row::with_shared_columns(output_col_shared.clone(), vals)
} else {
self.project_row(&row, &output_col_shared)?
};
if distinct && rows.contains(&projected) {
continue;
}
if skipped < skip_count {
skipped += 1;
continue;
}
rows.push(projected);
if let Some(lim) = limit
&& rows.len() >= lim
{
break;
}
}
Ok(rows)
}
Statement::VectorSearch {
columns,
table,
query_vector,
top_k,
where_clause,
..
} => {
let table_def = self
.catalog
.get_table(&table)
.cloned()
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
let root_page = table_def.root_page;
let all_col_names = table_def.column_names();
let output_col_names = if columns.is_empty() {
all_col_names.clone()
} else {
columns.clone()
};
let candidate_ids = if let Some(ref expr) = where_clause {
let resolved = self.resolve_where_expr(pager, expr)?;
let mut matched = std::collections::HashSet::new();
let mut used_index = false;
if let ResolvedWhereExpr::Condition(cond) = &resolved
&& cond.op == BinaryOp::Equals
&& let Some(index_def) = self.find_usable_index_for_column(
&table,
&cond.column,
where_clause.as_ref(),
)
{
let key = value_to_index_key(&cond.value);
if let Some(payload) = self.btree.search(pager, index_def.root_page, key)?
&& let Ok(bucket) = serde_json::from_slice::<IndexBucket>(&payload)
&& let Some(rids) = bucket.get_row_ids(&cond.value)
{
for &rid in rids {
matched.insert(rid);
}
used_index = true;
}
}
if !used_index {
let cells = self.btree.scan(pager, root_page)?;
for cell in cells {
if let Ok(full_row) = decode_row(&cell.payload, &all_col_names)
&& row_matches_resolved(&full_row, &resolved)
{
matched.insert(cell.row_id);
}
}
}
Some(matched)
} else {
None
};
let mut rows = Vec::new();
if let Some(index) = self.vector_indexes.get(&table.to_lowercase()) {
let neighbors = index.search_knn_filtered(
&query_vector,
top_k,
DistanceMetric::Cosine,
candidate_ids.as_ref(),
)?;
for (row_id, _) in neighbors {
if let Some(payload) = self.btree.search(pager, root_page, row_id)? {
let full_row = decode_row(&payload, &all_col_names)?;
let projected = self.project_row(&full_row, &output_col_names)?;
rows.push(projected);
}
}
} else {
let cells = self.btree.scan(pager, root_page)?;
if let Some((vec_idx, _)) = table_def.vector_column() {
let mut scored_rows: Vec<(f32, Row)> = Vec::new();
for cell in cells {
if let Some(ref allowed) = candidate_ids
&& !allowed.contains(&cell.row_id)
{
continue;
}
if let Ok(full_row) = decode_row(&cell.payload, &all_col_names)
&& let Some(crate::traits::Value::Vector(v)) =
full_row.values().get(vec_idx)
{
let dist = crate::vector::cosine_distance(&query_vector, v);
let projected = self.project_row(&full_row, &output_col_names)?;
scored_rows.push((dist, projected));
}
}
scored_rows.sort_by(|a, b| {
a.0.partial_cmp(&b.0).unwrap_or(std::cmp::Ordering::Equal)
});
for (_, row) in scored_rows.into_iter().take(top_k) {
rows.push(row);
}
} else {
for cell in cells.into_iter() {
if let Some(ref allowed) = candidate_ids
&& !allowed.contains(&cell.row_id)
{
continue;
}
let full_row = decode_row(&cell.payload, &all_col_names)?;
let projected = self.project_row(&full_row, &output_col_names)?;
rows.push(projected);
if rows.len() >= top_k {
break;
}
}
}
}
Ok(rows)
}
Statement::GraphTraverse {
start_id,
direction,
label,
max_depth,
where_clause,
} => {
let cols = vec![
"node_id".to_string(),
"label".to_string(),
"properties".to_string(),
"depth".to_string(),
];
let mut rows = Vec::new();
let mut visited = std::collections::HashSet::new();
let mut queue = std::collections::VecDeque::new();
let resolved_where = if let Some(ref expr) = where_clause {
Some(self.resolve_where_expr(pager, expr)?)
} else {
None
};
if let Some(start_node) = self.graph.get_node(start_id) {
visited.insert(start_id);
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(start_node.id as i64),
Value::Text(start_node.label.clone()),
Value::Text(start_node.properties.clone()),
Value::Integer(0),
],
));
queue.push_back((start_id, 0usize));
}
while let Some((curr_id, depth)) = queue.pop_front() {
if depth >= max_depth {
continue;
}
let neighbors = self
.graph
.neighbor_refs(curr_id, direction, label.as_deref());
for (neighbor_node, edge) in neighbors {
if visited.contains(&neighbor_node.id) {
continue;
}
if let Some(ref rw) = resolved_where {
let mut test_cols = vec![
"node_id".to_string(),
"id".to_string(),
"target.id".to_string(),
"label".to_string(),
"target.label".to_string(),
"depth".to_string(),
"weight".to_string(),
"edge.weight".to_string(),
"edge.label".to_string(),
];
let mut test_vals = vec![
Value::Integer(neighbor_node.id as i64),
Value::Integer(neighbor_node.id as i64),
Value::Integer(neighbor_node.id as i64),
Value::Text(neighbor_node.label.clone()),
Value::Text(neighbor_node.label.clone()),
Value::Integer((depth + 1) as i64),
Value::Real(edge.weight as f64),
Value::Real(edge.weight as f64),
Value::Text(edge.label.clone()),
];
if let Ok(serde_json::Value::Object(map)) =
serde_json::from_str::<serde_json::Value>(&neighbor_node.properties)
{
for (k, v) in map {
let db_val = match v {
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Integer(i)
} else if let Some(f) = n.as_f64() {
Value::Real(f)
} else {
Value::Null
}
}
serde_json::Value::String(s) => Value::Text(s),
serde_json::Value::Bool(b) => {
Value::Integer(if b { 1 } else { 0 })
}
serde_json::Value::Null => Value::Null,
other => Value::Text(other.to_string()),
};
test_cols.push(k.clone());
test_cols.push(format!("target.{k}"));
test_vals.push(db_val.clone());
test_vals.push(db_val);
}
}
let test_row = Row::new(test_cols, test_vals);
if !row_matches_resolved(&test_row, rw) {
continue;
}
}
if visited.insert(neighbor_node.id) {
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(neighbor_node.id as i64),
Value::Text(neighbor_node.label.clone()),
Value::Text(neighbor_node.properties.clone()),
Value::Integer((depth + 1) as i64),
],
));
queue.push_back((neighbor_node.id, depth + 1));
}
}
}
Ok(rows)
}
Statement::GraphShortestPath { start_id, end_id } => {
let cols = vec![
"step".to_string(),
"from_id".to_string(),
"to_id".to_string(),
"label".to_string(),
"weight".to_string(),
"total_cost".to_string(),
];
let mut rows = Vec::new();
if let Some((path, total_cost)) =
self.graph.dijkstra_shortest_path(start_id, end_id)
{
for (step_idx, edge) in path.into_iter().enumerate() {
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer((step_idx + 1) as i64),
Value::Integer(edge.from_id as i64),
Value::Integer(edge.to_id as i64),
Value::Text(edge.label),
Value::Real(edge.weight as f64),
Value::Real(total_cost as f64),
],
));
}
}
Ok(rows)
}
Statement::GraphMatch {
source_var,
source_label,
rel_var,
rel_label,
target_var,
target_label,
where_clause,
return_items,
} => {
let mut rows = Vec::new();
let resolved_where = if let Some(ref expr) = where_clause {
Some(self.resolve_where_expr(pager, expr)?)
} else {
None
};
let output_cols = return_items.clone();
for edge in self.graph.all_edges() {
if let Some(ref rl) = rel_label
&& !edge.label.eq_ignore_ascii_case(rl)
{
continue;
}
let source_node = match self.graph.get_node(edge.from_id) {
Some(n) => n,
None => continue,
};
if let Some(ref sl) = source_label
&& !source_node.label.eq_ignore_ascii_case(sl)
{
continue;
}
let target_node = match self.graph.get_node(edge.to_id) {
Some(n) => n,
None => continue,
};
if let Some(ref tl) = target_label
&& !target_node.label.eq_ignore_ascii_case(tl)
{
continue;
}
let mut test_cols = Vec::new();
let mut test_vals = Vec::new();
test_cols.push(format!("{source_var}.id"));
test_vals.push(Value::Integer(source_node.id as i64));
test_cols.push(format!("{source_var}.label"));
test_vals.push(Value::Text(source_node.label.clone()));
test_cols.push(format!("{source_var}.properties"));
test_vals.push(Value::Text(source_node.properties.clone()));
test_cols.push(format!("{target_var}.id"));
test_vals.push(Value::Integer(target_node.id as i64));
test_cols.push(format!("{target_var}.label"));
test_vals.push(Value::Text(target_node.label.clone()));
test_cols.push(format!("{target_var}.properties"));
test_vals.push(Value::Text(target_node.properties.clone()));
if let Some(ref rv) = rel_var {
test_cols.push(format!("{rv}.id"));
test_vals.push(Value::Integer(edge.id as i64));
test_cols.push(format!("{rv}.label"));
test_vals.push(Value::Text(edge.label.clone()));
test_cols.push(format!("{rv}.weight"));
test_vals.push(Value::Real(edge.weight as f64));
test_cols.push(format!("{rv}.properties"));
test_vals.push(Value::Text(edge.properties.clone()));
}
test_cols.push("edge.id".to_string());
test_vals.push(Value::Integer(edge.id as i64));
test_cols.push("edge.label".to_string());
test_vals.push(Value::Text(edge.label.clone()));
test_cols.push("edge.weight".to_string());
test_vals.push(Value::Real(edge.weight as f64));
if let Ok(serde_json::Value::Object(map)) =
serde_json::from_str::<serde_json::Value>(&source_node.properties)
{
for (k, v) in map {
let db_val = match v {
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Integer(i)
} else if let Some(f) = n.as_f64() {
Value::Real(f)
} else {
Value::Null
}
}
serde_json::Value::String(s) => Value::Text(s),
serde_json::Value::Bool(b) => Value::Integer(if b { 1 } else { 0 }),
serde_json::Value::Null => Value::Null,
other => Value::Text(other.to_string()),
};
test_cols.push(format!("{source_var}.{k}"));
test_vals.push(db_val);
}
}
if let Ok(serde_json::Value::Object(map)) =
serde_json::from_str::<serde_json::Value>(&target_node.properties)
{
for (k, v) in map {
let db_val = match v {
serde_json::Value::Number(n) => {
if let Some(i) = n.as_i64() {
Value::Integer(i)
} else if let Some(f) = n.as_f64() {
Value::Real(f)
} else {
Value::Null
}
}
serde_json::Value::String(s) => Value::Text(s),
serde_json::Value::Bool(b) => Value::Integer(if b { 1 } else { 0 }),
serde_json::Value::Null => Value::Null,
other => Value::Text(other.to_string()),
};
test_cols.push(format!("{target_var}.{k}"));
test_vals.push(db_val);
}
}
let test_row = Row::new(test_cols, test_vals);
if let Some(ref rw) = resolved_where
&& !row_matches_resolved(&test_row, rw)
{
continue;
}
let mut row_vals = Vec::new();
for ret_col in &output_cols {
if ret_col == "*" {
row_vals.push(Value::Integer(source_node.id as i64));
row_vals.push(Value::Text(source_node.label.clone()));
row_vals.push(Value::Text(edge.label.clone()));
row_vals.push(Value::Integer(target_node.id as i64));
row_vals.push(Value::Text(target_node.label.clone()));
} else if ret_col == &source_var {
row_vals.push(Value::Text(format!(
"(:{} {{id: {}, properties: {}}})",
source_node.label, source_node.id, source_node.properties
)));
} else if ret_col == &target_var {
row_vals.push(Value::Text(format!(
"(:{} {{id: {}, properties: {}}})",
target_node.label, target_node.id, target_node.properties
)));
} else if rel_var.as_ref() == Some(ret_col) {
row_vals.push(Value::Text(format!(
"[:{} {{id: {}, weight: {}}}]",
edge.label, edge.id, edge.weight
)));
} else if let Some(val) = test_row.get_value(ret_col) {
row_vals.push(val.clone());
} else {
row_vals.push(Value::Null);
}
}
rows.push(Row::new(output_cols.clone(), row_vals));
}
Ok(rows)
}
Statement::GraphAlgorithm { algorithm, options } => match algorithm.as_str() {
"PAGERANK" => {
let damping: f32 = options
.get("damping")
.and_then(|v| v.parse().ok())
.unwrap_or(0.85);
let iterations: usize = options
.get("iterations")
.and_then(|v| v.parse().ok())
.unwrap_or(20);
let tol: f32 = options
.get("tolerance")
.and_then(|v| v.parse().ok())
.unwrap_or(1e-4);
let ranks = self.graph.pagerank(damping, iterations, tol);
let cols = vec![
"node_id".to_string(),
"label".to_string(),
"pagerank".to_string(),
];
let mut rows = Vec::new();
let mut sorted: Vec<(u64, f32)> = ranks.into_iter().collect();
sorted
.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
for (id, rank) in sorted {
let label = self
.graph
.get_node(id)
.map(|n| n.label.clone())
.unwrap_or_default();
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id as i64),
Value::Text(label),
Value::Real(rank as f64),
],
));
}
Ok(rows)
}
"CONNECTED_COMPONENTS" | "COMPONENTS" | "WCC" => {
let components = self.graph.connected_components();
let cols = vec![
"node_id".to_string(),
"label".to_string(),
"component_id".to_string(),
];
let mut rows = Vec::new();
let mut sorted: Vec<(u64, usize)> = components.into_iter().collect();
sorted.sort_by_key(|&(id, comp)| (comp, id));
for (id, comp) in sorted {
let label = self
.graph
.get_node(id)
.map(|n| n.label.clone())
.unwrap_or_default();
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id as i64),
Value::Text(label),
Value::Integer(comp as i64),
],
));
}
Ok(rows)
}
"BETWEENNESS" | "BETWEENNESS_CENTRALITY" => {
let normalized = options
.get("normalized")
.map(|v| v != "false" && v != "0")
.unwrap_or(true);
let scores = self.graph.betweenness_centrality(normalized);
let cols = vec![
"node_id".to_string(),
"label".to_string(),
"betweenness".to_string(),
];
let mut rows = Vec::new();
let mut sorted: Vec<(u64, f32)> = scores.into_iter().collect();
sorted
.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal));
for (id, score) in sorted {
let label = self
.graph
.get_node(id)
.map(|n| n.label.clone())
.unwrap_or_default();
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id as i64),
Value::Text(label),
Value::Real(score as f64),
],
));
}
Ok(rows)
}
"LOUVAIN" | "COMMUNITIES" => {
let communities = self.graph.louvain_communities();
let cols = vec![
"node_id".to_string(),
"label".to_string(),
"community_id".to_string(),
];
let mut rows = Vec::new();
let mut sorted: Vec<(u64, usize)> = communities.into_iter().collect();
sorted.sort_by_key(|&(id, comm)| (comm, id));
for (id, comm) in sorted {
let label = self
.graph
.get_node(id)
.map(|n| n.label.clone())
.unwrap_or_default();
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id as i64),
Value::Text(label),
Value::Integer(comm as i64),
],
));
}
Ok(rows)
}
unknown => Err(Error::SqlSyntax(format!(
"Unknown graph algorithm '{unknown}'. Supported: PAGERANK, CONNECTED_COMPONENTS, BETWEENNESS, LOUVAIN"
))),
},
Statement::Pragma { key, value } => {
let k = key.to_lowercase();
if k == "table_info" {
let target_table = value.unwrap_or_default();
let cols = vec![
"cid".to_string(),
"name".to_string(),
"type".to_string(),
"notnull".to_string(),
"dflt_value".to_string(),
"pk".to_string(),
];
let mut rows = Vec::new();
if let Some(tdef) = self.catalog.get_table(&target_table) {
for (cid, col) in tdef.columns.iter().enumerate() {
let dtype = format!("{:?}", col.data_type).to_uppercase();
let dflt = col
.default_value
.as_ref()
.map(|d| Value::Text(format!("{:?}", d.materialize())))
.unwrap_or(Value::Null);
let pk_num = if col.primary_key {
1
} else if let Some(pos) = tdef
.primary_key_columns
.iter()
.position(|p| p.eq_ignore_ascii_case(&col.name))
{
(pos + 1) as i64
} else {
0
};
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(cid as i64),
Value::Text(col.name.clone()),
Value::Text(dtype),
Value::Integer(if col.not_null { 1 } else { 0 }),
dflt,
Value::Integer(pk_num),
],
));
}
}
Ok(rows)
} else if k == "foreign_keys" {
if let Some(v) = value {
let val_lower = v.trim().to_lowercase();
self.foreign_keys_enabled =
val_lower == "1" || val_lower == "true" || val_lower == "on";
}
Ok(vec![Row::new(
vec!["foreign_keys".to_string()],
vec![Value::Integer(if self.foreign_keys_enabled {
1
} else {
0
})],
)])
} else {
Ok(Vec::new())
}
}
other => Err(Error::SqlSyntax(format!(
"Non-query statement {other:?} passed to query()"
))),
}
}
fn explain_query_plan(
&self,
_pager: &mut Pager,
stmt: Statement,
_is_query_plan: bool,
) -> Result<Vec<Row>> {
let mut rows = Vec::new();
let cols = vec!["id".to_string(), "parent".to_string(), "detail".to_string()];
match stmt {
Statement::Select {
table,
join,
where_clause,
order_by,
limit,
..
} => {
let table_def = self.catalog.get_table(&table);
let pk_idx = table_def.and_then(|t| t.primary_key_index());
let mut id = 0;
let optimizer = crate::sql::planner::CostOptimizer::new();
let default_stats = crate::sql::planner::TableStats::new(&table, 100, 10);
let stats = self
.catalog
.get_table_stats(&table)
.unwrap_or(&default_stats);
let mut is_pk_search = false;
if join.is_none()
&& order_by.is_none()
&& let (Some(pk_col_idx), Some(WhereExpr::Condition(cond))) =
(pk_idx, &where_clause)
&& cond.op == BinaryOp::Equals
&& let Some(tdef) = table_def
&& tdef.columns[pk_col_idx]
.name
.eq_ignore_ascii_case(&cond.column)
{
is_pk_search = true;
let cost = optimizer.estimate_pk_lookup(stats);
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!(
"SEARCH TABLE {} USING PRIMARY KEY ({} = {:?}) {}",
table, cond.column, cond.value, cost
)),
],
));
id += 1;
}
let mut is_index_search = false;
if !is_pk_search && join.is_none() && order_by.is_none() {
if let Some(ref expr) = where_clause {
let mut and_eqs = HashMap::new();
collect_and_eq_conditions(expr, &mut and_eqs);
if and_eqs.len() >= 2
&& let Some(idx_def) = self
.catalog
.indexes()
.into_iter()
.filter(|idx| {
idx.table.eq_ignore_ascii_case(&table)
&& partial_index_matches_query(idx, where_clause.as_ref())
})
.filter(|idx| {
let cols = idx.target_columns();
cols.len() >= 2
&& cols
.iter()
.all(|c| and_eqs.contains_key(&c.to_lowercase()))
})
.max_by_key(|idx| idx.target_columns().len())
{
is_index_search = true;
let tcols = idx_def.target_columns().join(", ");
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!(
"SEARCH TABLE {} USING COMPOSITE INDEX {} ({})",
table, idx_def.name, tcols
)),
],
));
id += 1;
}
}
if !is_index_search && let Some(ref w_expr) = where_clause {
let mut eq_conds = HashMap::new();
collect_and_eq_conditions(w_expr, &mut eq_conds);
if let Some((col_key, col_val, idx_def)) =
eq_conds.iter().find_map(|(c, v)| {
self.find_usable_index_for_column(&table, c, Some(w_expr))
.map(|idx| (c.clone(), v.clone(), idx))
})
{
is_index_search = true;
let sel = stats.estimate_selectivity(&col_key, true);
let cost =
optimizer.estimate_index_scan(stats, &idx_def.name, &col_key, sel);
let idx_kind = if idx_def.predicate_sql.is_some() {
"PARTIAL INDEX"
} else {
"INDEX"
};
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!(
"SEARCH TABLE {} USING {} {} ({} = {:?}) {}",
table, idx_kind, idx_def.name, col_key, col_val, cost
)),
],
));
id += 1;
}
}
}
if !is_pk_search && !is_index_search {
let filter_str = if let Some(ref expr) = where_clause {
format!(" WITH FILTER ({expr:?})")
} else {
String::new()
};
let cost = optimizer.estimate_seq_scan(stats, 1.0);
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!("SCAN TABLE {}{filter_str} {}", table, cost)),
],
));
id += 1;
}
if let Some(j) = join {
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!(
"SEARCH SUBQUERY / JOIN TABLE {} ON {}.{} = {}.{}",
j.table, table, j.left_col, j.table, j.right_col
)),
],
));
id += 1;
}
if let Some(ord) = order_by {
let dir = if ord.is_ascending { "ASC" } else { "DESC" };
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!(
"USE TEMP B-TREE FOR ORDER BY {} {}",
ord.column, dir
)),
],
));
id += 1;
}
if let Some(lim) = limit {
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(id),
Value::Integer(0),
Value::Text(format!("LIMIT {}", lim)),
],
));
}
}
Statement::VectorSearch {
table,
vector_col,
top_k,
query_vector,
..
} => {
let optimizer = crate::sql::planner::CostOptimizer::new();
let default_stats = crate::sql::planner::TableStats::new(&table, 100, 10);
let stats = self
.catalog
.get_table_stats(&table)
.unwrap_or(&default_stats);
let has_hnsw = self.vector_indexes.contains_key(&table.to_lowercase());
let cost =
optimizer.estimate_vector_search(stats, top_k, query_vector.len(), has_hnsw);
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(0),
Value::Integer(0),
Value::Text(format!(
"SEARCH TABLE {} USING {} ON {} (TOP {}) {}",
table,
if has_hnsw {
"HNSW VECTOR INDEX"
} else {
"BRUTE-FORCE SCAN"
},
vector_col,
top_k,
cost
)),
],
));
}
_ => {
rows.push(Row::new(
cols.clone(),
vec![
Value::Integer(0),
Value::Integer(0),
Value::Text("EXECUTE STATEMENT (DIRECT B-TREE ENGINE)".to_string()),
],
));
}
}
Ok(rows)
}
fn query_with_cte(
&mut self,
pager: &mut Pager,
ctes: Vec<crate::sql::parser::CteClause>,
main_query: Statement,
) -> Result<Vec<Row>> {
let mut cte_store: HashMap<String, Vec<Row>> = HashMap::new();
for cte in ctes {
let cte_key = cte.name.to_ascii_lowercase();
let mapped_rows = if cte.recursive
&& let Statement::Compound { left, op, right } = *cte.query
{
self.execute_recursive_cte(
pager,
&cte_key,
cte.columns.as_deref(),
*left,
op,
*right,
&cte_store,
)?
} else {
let rows = self.eval_cte_statement(pager, *cte.query, &cte_store)?;
apply_cte_column_names(rows, cte.columns.as_deref())
};
cte_store.insert(cte_key, mapped_rows);
}
self.eval_cte_statement(pager, main_query, &cte_store)
}
fn eval_cte_statement(
&mut self,
pager: &mut Pager,
stmt: Statement,
cte_store: &HashMap<String, Vec<Row>>,
) -> Result<Vec<Row>> {
match stmt {
Statement::Compound { left, op, right } => {
let mut left_rows = self.eval_cte_statement(pager, *left, cte_store)?;
let right_rows = self.eval_cte_statement(pager, *right, cte_store)?;
combine_compound_rows(&mut left_rows, right_rows, op);
Ok(left_rows)
}
Statement::Select {
ref table,
ref join,
..
} if cte_store.contains_key(&table.to_ascii_lowercase())
|| join
.as_ref()
.is_some_and(|j| cte_store.contains_key(&j.table.to_ascii_lowercase())) =>
{
self.query_on_ephemeral_rows(pager, stmt, cte_store)
}
other => self.query(pager, other),
}
}
#[allow(clippy::too_many_arguments)]
fn execute_recursive_cte(
&mut self,
pager: &mut Pager,
cte_key: &str,
explicit_cols: Option<&[String]>,
anchor: Statement,
op: crate::sql::parser::SetOperation,
recursive_step: Statement,
outer_store: &HashMap<String, Vec<Row>>,
) -> Result<Vec<Row>> {
const MAX_RECURSIVE_ITERATIONS: usize = 10_000;
let anchor_rows = apply_cte_column_names(
self.eval_cte_statement(pager, anchor, outer_store)?,
explicit_cols,
);
let mut accumulated = Vec::new();
let mut seen: Option<HashSet<String>> =
(op == crate::sql::parser::SetOperation::Union).then(HashSet::new);
let mut working = Vec::with_capacity(anchor_rows.len());
for row in anchor_rows {
if let Some(ref mut set) = seen
&& !set.insert(format!("{:?}", row.values()))
{
continue;
}
accumulated.push(row.clone());
working.push(row);
}
let mut step_store = outer_store.clone();
let mut iterations = 0usize;
while !working.is_empty() {
iterations += 1;
if iterations > MAX_RECURSIVE_ITERATIONS {
return Err(Error::SqlSyntax(format!(
"WITH RECURSIVE '{cte_key}' exceeded maximum recursion depth ({MAX_RECURSIVE_ITERATIONS})"
)));
}
step_store.insert(cte_key.to_string(), working);
let raw_next = self.eval_cte_statement(pager, recursive_step.clone(), &step_store)?;
let next_mapped = apply_cte_column_names(raw_next, explicit_cols);
let mut next_working = Vec::new();
for row in next_mapped {
if let Some(ref mut set) = seen
&& !set.insert(format!("{:?}", row.values()))
{
continue;
}
accumulated.push(row.clone());
next_working.push(row);
}
working = next_working;
}
Ok(accumulated)
}
fn query_on_ephemeral_rows(
&mut self,
pager: &mut Pager,
stmt: Statement,
cte_store: &HashMap<String, Vec<Row>>,
) -> Result<Vec<Row>> {
if let Statement::Select {
distinct,
columns,
table,
join,
where_clause,
group_by,
having,
order_by,
limit,
offset,
..
} = stmt
{
let base_rows = if table.is_empty() {
vec![Row::new(Vec::new(), Vec::new())]
} else if let Some(cte_rows) = cte_store.get(&table.to_ascii_lowercase()) {
cte_rows.clone()
} else if self.catalog.table_exists(&table) {
self.query(
pager,
Statement::Select {
distinct: false,
columns: Vec::new(),
table: table.clone(),
from_subquery: None,
join: None,
where_clause: None,
group_by: None,
having: None,
order_by: None,
limit: None,
offset: None,
as_of_timestamp: None,
},
)?
} else {
return Err(Error::TableNotFound(table.clone()));
};
let mut rows = base_rows;
if let Some(ref j) = join {
let right_rows = if let Some(r_cte) = cte_store.get(&j.table.to_ascii_lowercase()) {
r_cte.clone()
} else if self.catalog.table_exists(&j.table) {
self.query(
pager,
Statement::Select {
distinct: false,
columns: vec![],
table: j.table.clone(),
from_subquery: None,
join: None,
where_clause: None,
group_by: None,
having: None,
order_by: None,
limit: None,
offset: None,
as_of_timestamp: None,
},
)?
} else {
return Err(Error::TableNotFound(j.table.clone()));
};
let mut joined_rows = Vec::new();
for left_r in &rows {
let mut matched = false;
for right_r in &right_rows {
let left_v = left_r.get_value(&j.left_col);
let right_v = right_r.get_value(&j.right_col);
if let (Some(lv), Some(rv)) = (left_v, right_v)
&& lv == rv
&& !lv.is_null()
{
matched = true;
let mut j_cols = left_r.columns().to_vec();
let mut j_vals = left_r.values().to_vec();
for (rc, rv) in right_r.columns().iter().zip(right_r.values().iter()) {
j_cols.push(format!("{}.{}", j.table, rc));
j_vals.push(rv.clone());
if !j_cols.contains(rc) {
j_cols.push(rc.clone());
j_vals.push(rv.clone());
}
}
joined_rows.push(Row::new(j_cols, j_vals));
}
}
if !matched && j.is_left {
let mut j_cols = left_r.columns().to_vec();
let mut j_vals = left_r.values().to_vec();
if let Some(first_r) = right_rows.first() {
for rc in first_r.columns() {
j_cols.push(format!("{}.{}", j.table, rc));
j_vals.push(Value::Null);
if !j_cols.contains(rc) {
j_cols.push(rc.clone());
j_vals.push(Value::Null);
}
}
}
joined_rows.push(Row::new(j_cols, j_vals));
}
}
rows = joined_rows;
}
if let Some(ref expr) = where_clause {
let resolved = self.resolve_where_expr(pager, expr)?;
rows.retain(|r| row_matches_resolved(r, &resolved));
}
if let Some(ref gb_cols) = group_by {
let resolved_having = if let Some(ref h) = having {
Some(self.resolve_where_expr(pager, h)?)
} else {
None
};
rows = aggregate_ephemeral_rows(&rows, &columns, gb_cols, resolved_having.as_ref());
} else if is_aggregate_query(&columns) {
let mut agg_cols = Vec::new();
let mut agg_vals = Vec::new();
for col in &columns {
if let Some(spec) = parse_aggregate_spec(col) {
let computed = compute_aggregate_from_spec(&spec, &rows);
agg_cols.push(spec.output_name);
agg_vals.push(computed);
} else {
agg_cols.push(parse_col_and_alias(col).1.unwrap_or(col).to_string());
agg_vals.push(Value::Null);
}
}
return Ok(vec![Row::new(agg_cols, agg_vals)]);
} else if !columns.is_empty() && columns[0] != "*" {
rows = rows
.iter()
.map(|r| self.project_row(r, &columns))
.collect::<Result<Vec<Row>>>()?;
}
if let Some(ref order) = order_by {
rows.sort_by(|a, b| {
let val_a = a.get_value(&order.column).unwrap_or(&Value::Null);
let val_b = b.get_value(&order.column).unwrap_or(&Value::Null);
if order.is_ascending {
val_a.compare(val_b)
} else {
val_b.compare(val_a)
}
});
}
if distinct {
let mut seen = HashSet::new();
rows.retain(|r| {
let key = format!("{:?}", r.values());
seen.insert(key)
});
}
if let Some(off) = offset {
if off < rows.len() {
rows = rows.split_off(off);
} else {
rows.clear();
}
}
if let Some(lim) = limit {
rows.truncate(lim);
}
Ok(rows)
} else {
Err(Error::SqlSyntax("Expected SELECT in CTE main query".into()))
}
}
pub fn execute_insert_batch(
&mut self,
pager: &mut Pager,
table: &str,
columns: Option<&[String]>,
rows: &[Vec<Value>],
) -> Result<usize> {
if rows.is_empty() {
return Ok(0);
}
let (
root_page,
table_cols,
pk_idx,
vector_col,
is_temporal,
initial_next_row_id,
needs_full_path,
) = {
let table_def = self
.catalog
.get_table(table)
.ok_or_else(|| Error::TableNotFound(table.to_string()))?;
let has_triggers = self
.catalog
.triggers()
.iter()
.any(|t| t.table.eq_ignore_ascii_case(table));
let has_indexes = self
.catalog
.indexes()
.iter()
.any(|idx| idx.table.eq_ignore_ascii_case(table));
let has_checks = !table_def.check_constraints.is_empty();
let has_fks =
self.foreign_keys_enabled && !collect_table_foreign_keys(table_def).is_empty();
let has_unique_cols = table_def.columns.iter().any(|c| c.unique && !c.primary_key);
let is_temporal = table_def.system_versioning || self.default_system_versioning;
let has_fts = table_def.fts_config.is_some();
let complex = has_triggers
|| has_indexes
|| has_checks
|| has_fks
|| has_unique_cols
|| is_temporal
|| has_fts;
(
table_def.root_page,
table_def.columns.clone(),
table_def.primary_key_index(),
table_def.vector_column(),
is_temporal,
table_def.next_row_id,
complex,
)
};
let _ = is_temporal;
if needs_full_path {
let cols_owned = columns.map(<[String]>::to_vec);
return self.atomic_statement(pager, |executor, pager| {
let mut total = 0usize;
for row_vals in rows {
let (n, _) = executor.execute_insert(
pager,
table.to_string(),
cols_owned.clone(),
row_vals.clone(),
OnConflict::Abort,
None,
)?;
total += n;
}
Ok(total)
});
}
let col_mapping: Option<Vec<usize>> = if let Some(cols) = columns {
let table_def = self.catalog.get_table(table).unwrap();
let mut map = Vec::with_capacity(cols.len());
for c_name in cols {
let idx = table_def
.column_index(c_name)
.ok_or_else(|| Error::Corrupted(format!("Unknown column: {c_name}")))?;
map.push(idx);
}
Some(map)
} else {
None
};
let template_defaults: Vec<Value> = table_cols
.iter()
.map(|c| {
c.default_value
.as_ref()
.map(DefaultValue::materialize)
.unwrap_or(Value::Null)
})
.collect();
let num_cols = table_cols.len();
self.atomic_statement(pager, |executor, pager| {
let mut next_row_id = initial_next_row_id;
let mut last_row_id = 0u64;
let mut inserted = 0usize;
let mut aligned = Vec::with_capacity(num_cols);
let mut encode_buf = Vec::with_capacity(256);
for input_vals in rows {
aligned.clear();
if let Some(ref map) = col_mapping {
if map.len() != input_vals.len() {
return Err(Error::SqlSyntax(
"Column count does not match value count in INSERT batch".into(),
));
}
aligned.extend(template_defaults.iter().cloned());
for (&dst_idx, val) in map.iter().zip(input_vals.iter()) {
aligned[dst_idx] = val.clone();
}
} else {
if input_vals.len() != num_cols {
return Err(Error::SqlSyntax(format!(
"INSERT requires {} values, got {}",
num_cols,
input_vals.len()
)));
}
aligned.extend(input_vals.iter().cloned());
}
for (col_idx, col_def) in table_cols.iter().enumerate() {
let orig = std::mem::replace(&mut aligned[col_idx], Value::Null);
let coerced = col_def.data_type.coerce_value(orig).map_err(|e| match e {
Error::DimensionMismatch(exp, got) => Error::DimensionMismatch(exp, got),
Error::ConstraintViolation(msg) => Error::ConstraintViolation(format!(
"{table}.{}: {msg}",
col_def.name
)),
other => other,
})?;
if col_def.not_null && coerced.is_null() {
return Err(Error::ConstraintViolation(format!(
"NOT NULL constraint failed: {table}.{}",
col_def.name
)));
}
aligned[col_idx] = coerced;
}
let (row_id, need_pk_check) = if let Some(idx) = pk_idx {
match &aligned[idx] {
Value::Integer(i) => {
let id_val = *i as u64;
if id_val >= next_row_id {
next_row_id = id_val + 1;
(id_val, false)
} else {
(id_val, true)
}
}
Value::Null => {
let rid = next_row_id;
next_row_id += 1;
aligned[idx] = Value::Integer(rid as i64);
(rid, false)
}
_ => {
let rid = next_row_id;
next_row_id += 1;
(rid, false)
}
}
} else {
let rid = next_row_id;
next_row_id += 1;
(rid, false)
};
if need_pk_check && executor.btree.search(pager, root_page, row_id)?.is_some() {
let pk_col_name = pk_idx
.map(|i| table_cols[i].name.as_str())
.unwrap_or("id");
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {table}.{pk_col_name} (key {row_id} already exists)"
)));
}
encode_row_into(&aligned, &mut encode_buf);
executor.btree.insert(pager, root_page, row_id, &encode_buf)?;
if let Some((v_idx, _)) = vector_col
&& let Some(Value::Vector(vec_data)) = aligned.get(v_idx)
{
let index = executor
.vector_indexes
.entry(table.to_lowercase())
.or_insert_with(|| HnswIndex::new(vec_data.len(), DistanceMetric::Cosine));
index.insert_vector(row_id, vec_data)?;
}
last_row_id = row_id;
inserted += 1;
}
if let Some(table_def) = executor.catalog.get_table_mut(table) {
table_def.next_row_id = next_row_id;
}
if inserted > 0 {
executor.last_insert_rowid = last_row_id as i64;
}
Ok(inserted)
})
}
#[cfg(feature = "std")]
fn execute_copy_from(
&mut self,
pager: &mut Pager,
table: &str,
source: &str,
format: Option<&str>,
options: &[(String, String)],
) -> Result<usize> {
let fmt = crate::lakehouse::DataFormat::parse_format_or_path(format, source)?;
let src_table = options
.iter()
.find(|(k, _)| k == "TABLE")
.map(|(_, v)| v.as_str());
let scan_tag = match fmt {
crate::lakehouse::DataFormat::Csv => "read_csv",
crate::lakehouse::DataFormat::Tsv => "read_tsv",
crate::lakehouse::DataFormat::Jsonl => "read_jsonl",
crate::lakehouse::DataFormat::Parquet => "read_parquet",
crate::lakehouse::DataFormat::Excel => "read_excel",
crate::lakehouse::DataFormat::Sqlite => "read_sqlite",
crate::lakehouse::DataFormat::Pdf => "read_pdf",
crate::lakehouse::DataFormat::Text | crate::lakehouse::DataFormat::Markdown => {
"read_text"
}
other => {
return Err(Error::SqlSyntax(format!(
"COPY FROM does not support {other:?} directly via SQL; use `tapirus convert`."
)));
}
};
let ext_rows = crate::lakehouse::scan_external_rows(scan_tag, source, src_table, None)?;
if ext_rows.is_empty() {
return Ok(0);
}
let cols = ext_rows[0].columns().to_vec();
if self.catalog.get_table(table).is_none() {
let mut col_defs = Vec::with_capacity(cols.len());
for (c_idx, c_name) in cols.iter().enumerate() {
let mut has_int = false;
let mut has_real = false;
let mut has_blob = false;
let mut has_vec: Option<usize> = None;
let mut has_text = false;
for r in ext_rows.iter().take(256) {
if let Some(v) = r.values().get(c_idx) {
match v {
Value::Null => {}
Value::Integer(_) => has_int = true,
Value::Real(_) => has_real = true,
Value::Blob(_) => has_blob = true,
Value::Vector(vec) => has_vec = Some(vec.len()),
Value::Text(_) => has_text = true,
}
}
}
let ty = if has_text {
"TEXT".to_string()
} else if let Some(d) = has_vec {
format!("VECTOR({d})")
} else if has_blob {
"BLOB".to_string()
} else if has_real {
"REAL".to_string()
} else if has_int {
"INTEGER".to_string()
} else {
"TEXT".to_string()
};
col_defs.push(format!("{c_name} {ty}"));
}
let ddl = format!(
"CREATE TABLE IF NOT EXISTS {table} ({});",
col_defs.join(", ")
);
let parsed = crate::sql::parser::parse_sql(&ddl)?;
self.execute_inner(pager, parsed)?;
}
let mut total = 0usize;
for chunk in ext_rows.chunks(2048) {
let batch: Vec<Vec<Value>> = chunk.iter().map(|r| r.values().to_vec()).collect();
total += self.execute_insert_batch(pager, table, Some(&cols), &batch)?;
}
Ok(total)
}
#[cfg(not(feature = "std"))]
fn execute_copy_from(
&mut self,
_pager: &mut Pager,
_table: &str,
_source: &str,
_format: Option<&str>,
_options: &[(String, String)],
) -> Result<usize> {
Err(Error::SqlSyntax(
"COPY FROM requires the 'std' feature".into(),
))
}
#[cfg(feature = "std")]
fn execute_copy_to(
&mut self,
pager: &mut Pager,
source_table: Option<&str>,
source_query: Option<&Statement>,
dest: &str,
format: Option<&str>,
partition_by: Option<&str>,
) -> Result<usize> {
let (rows, tbl_label) = if let Some(q) = source_query {
(self.query_inner(pager, q.clone())?, "query_export")
} else if let Some(tbl) = source_table {
let sel = crate::sql::parser::parse_sql(&format!("SELECT * FROM {tbl};"))?;
(self.query_inner(pager, sel)?, tbl)
} else {
return Err(Error::SqlSyntax(
"COPY TO requires a table name or (SELECT ...) query".into(),
));
};
let stats = crate::lakehouse::export_rows_to_path(
&rows,
tbl_label,
std::path::Path::new(dest),
format,
partition_by,
)?;
Ok(stats.rows_exported)
}
#[cfg(not(feature = "std"))]
fn execute_copy_to(
&mut self,
_pager: &mut Pager,
_source_table: Option<&str>,
_source_query: Option<&Statement>,
_dest: &str,
_format: Option<&str>,
_partition_by: Option<&str>,
) -> Result<usize> {
Err(Error::SqlSyntax(
"COPY TO requires the 'std' feature".into(),
))
}
pub fn execute_insert_fast(
&mut self,
pager: &mut Pager,
table: &str,
columns: Option<&[String]>,
values: &[Value],
encode_buf: Option<&mut Vec<u8>>,
) -> Result<(usize, Vec<Row>)> {
if let Some(table_def) = self.catalog.get_table(table) {
let has_complex = self.catalog.has_table_triggers(table)
|| self.catalog.has_table_indexes(table)
|| !table_def.check_constraints.is_empty()
|| (self.foreign_keys_enabled && !collect_table_foreign_keys(table_def).is_empty())
|| table_def.columns.iter().any(|c| c.unique && !c.primary_key)
|| !table_def.unique_constraints.is_empty()
|| table_def.system_versioning
|| self.default_system_versioning
|| table_def.fts_config.is_some()
|| table_def.vector_column().is_some();
if !has_complex {
let root_page = table_def.root_page;
let num_cols = table_def.columns.len();
let pk_idx = table_def.primary_key_index();
let current_next_row_id = table_def.next_row_id;
self.insert_scratch_vals.clear();
if let Some(cols) = columns {
if cols.len() != values.len() {
return Err(Error::SqlSyntax(
"Column count does not match value count in INSERT".into(),
));
}
for c in &table_def.columns {
self.insert_scratch_vals.push(
c.default_value
.as_ref()
.map(DefaultValue::materialize)
.unwrap_or(Value::Null),
);
}
for (c_name, val) in cols.iter().zip(values.iter()) {
let idx = table_def
.column_index(c_name)
.ok_or_else(|| Error::Corrupted(format!("Unknown column: {c_name}")))?;
self.insert_scratch_vals[idx] = val.clone();
}
} else {
if values.len() != num_cols {
return Err(Error::SqlSyntax(format!(
"INSERT requires {} values, got {}",
num_cols,
values.len()
)));
}
self.insert_scratch_vals.extend(values.iter().cloned());
}
for (col_idx, col_def) in table_def.columns.iter().enumerate() {
let orig =
std::mem::replace(&mut self.insert_scratch_vals[col_idx], Value::Null);
let coerced = col_def.data_type.coerce_value(orig).map_err(|e| match e {
Error::DimensionMismatch(exp, got) => Error::DimensionMismatch(exp, got),
Error::ConstraintViolation(msg) => {
Error::ConstraintViolation(format!("{table}.{}: {msg}", col_def.name))
}
other => other,
})?;
if col_def.not_null && coerced.is_null() {
return Err(Error::ConstraintViolation(format!(
"NOT NULL constraint failed: {table}.{}",
col_def.name
)));
}
self.insert_scratch_vals[col_idx] = coerced;
}
let mut next_rid = current_next_row_id;
let (row_id, need_pk_check) = if let Some(idx) = pk_idx {
match &self.insert_scratch_vals[idx] {
Value::Integer(i) => {
let id_val = *i as u64;
if id_val >= next_rid {
next_rid = id_val + 1;
(id_val, false)
} else {
(id_val, true)
}
}
Value::Null => {
let rid = next_rid;
next_rid += 1;
self.insert_scratch_vals[idx] = Value::Integer(rid as i64);
(rid, false)
}
_ => {
let rid = next_rid;
next_rid += 1;
(rid, false)
}
}
} else {
let rid = next_rid;
next_rid += 1;
(rid, false)
};
if need_pk_check && self.btree.search(pager, root_page, row_id)?.is_some() {
let pk_col_name = pk_idx
.map(|i| table_def.columns[i].name.as_str())
.unwrap_or("id");
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {table}.{pk_col_name} (key {row_id} already exists)"
)));
}
let buf = match encode_buf {
Some(b) => b,
None => &mut self.insert_scratch_buf,
};
encode_row_into(&self.insert_scratch_vals, buf);
let own_tx = !pager.is_in_transaction();
if own_tx {
pager.begin_transaction()?;
}
if let Err(err) = self.btree.insert(pager, root_page, row_id, buf) {
if own_tx && pager.is_in_transaction() {
let _ = pager.rollback_transaction();
}
return Err(err);
}
if own_tx && let Err(err) = pager.commit_transaction() {
if pager.is_in_transaction() {
let _ = pager.rollback_transaction();
}
let _ = self.reload_from_pager(pager);
return Err(err);
}
if let Some(table_def_mut) = self.catalog.get_table_mut(table) {
table_def_mut.next_row_id = next_rid;
}
self.last_insert_rowid = row_id as i64;
return Ok((1, Vec::new()));
}
}
let statement = Statement::Insert {
table: table.to_owned(),
columns: columns.map(<[String]>::to_vec),
values: values.to_vec(),
conflict_action: OnConflict::Abort,
returning: None,
};
self.atomic_statement(pager, |executor, pager| {
if let Statement::Insert {
table,
columns,
values,
conflict_action,
returning,
} = statement
{
executor.execute_insert(pager, table, columns, values, conflict_action, returning)
} else {
unreachable!()
}
})
}
fn execute_insert(
&mut self,
pager: &mut Pager,
table: String,
columns: Option<Vec<String>>,
values: Vec<Value>,
conflict_action: OnConflict,
returning: Option<Vec<String>>,
) -> Result<(usize, Vec<Row>)> {
let table_def_snapshot;
let table_cols;
let root_page;
let row_id;
let key_may_exist;
let mut aligned_values;
let vector_col;
let is_temporal;
{
let table_def = self
.catalog
.get_table_mut(&table)
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
root_page = table_def.root_page;
table_cols = table_def.columns.clone();
vector_col = table_def.vector_column();
is_temporal = table_def.system_versioning || self.default_system_versioning;
aligned_values = if let Some(cols) = columns {
if cols.len() != values.len() {
return Err(Error::SqlSyntax(
"Column count does not match value count in INSERT".into(),
));
}
let mut row_vals: Vec<Value> = table_cols
.iter()
.map(|c| {
c.default_value
.as_ref()
.map(DefaultValue::materialize)
.unwrap_or(Value::Null)
})
.collect();
for (c_name, val) in cols.iter().zip(values) {
let idx = table_def
.column_index(c_name)
.ok_or_else(|| Error::Corrupted(format!("Unknown column: {c_name}")))?;
row_vals[idx] = val;
}
row_vals
} else {
if values.len() != table_cols.len() {
return Err(Error::SqlSyntax(format!(
"INSERT requires {} values, got {}",
table_cols.len(),
values.len()
)));
}
values
};
let pk_idx = table_def.primary_key_index();
let (rid, may_exist) = if let Some(idx) = pk_idx {
match &aligned_values[idx] {
Value::Integer(i) => {
let id_val = *i as u64;
if id_val >= table_def.next_row_id {
table_def.next_row_id = id_val + 1;
}
(id_val, true)
}
Value::Null => {
let rid = table_def.next_row_id;
table_def.next_row_id += 1;
aligned_values[idx] = Value::Integer(rid as i64);
(rid, false)
}
_ => {
let rid = table_def.next_row_id;
table_def.next_row_id += 1;
(rid, false)
}
}
} else {
let rid = table_def.next_row_id;
table_def.next_row_id += 1;
(rid, false)
};
row_id = rid;
key_may_exist = may_exist;
table_def_snapshot = table_def.clone();
}
for (col_idx, col_def) in table_cols.iter().enumerate() {
if let Some(val) = aligned_values.get_mut(col_idx) {
let orig = std::mem::replace(val, Value::Null);
*val = col_def.data_type.coerce_value(orig).map_err(|e| match e {
Error::DimensionMismatch(exp, got) => Error::DimensionMismatch(exp, got),
Error::ConstraintViolation(msg) => {
Error::ConstraintViolation(format!("{table}.{}: {msg}", col_def.name))
}
other => other,
})?;
}
}
for (col_idx, col_def) in table_cols.iter().enumerate() {
if col_def.not_null
&& let Some(val) = aligned_values.get(col_idx)
&& val.is_null()
{
return Err(Error::ConstraintViolation(format!(
"NOT NULL constraint failed: {table}.{}",
col_def.name
)));
}
}
let all_col_names: Vec<String> = table_cols.iter().map(|c| c.name.clone()).collect();
let candidate_row = Row::new(all_col_names.clone(), aligned_values.clone());
if !self.fire_triggers(
pager,
&table,
TriggerTiming::Before,
TriggerEvent::Insert,
None,
Some(&candidate_row),
)? {
return Ok((0, Vec::new()));
}
let existing_payload = if key_may_exist {
self.btree.search(pager, root_page, row_id)?
} else {
None
};
if let Some(existing_payload) = existing_payload {
match conflict_action {
OnConflict::Abort => {
let pk_col_name = table_cols
.iter()
.find(|c| c.primary_key)
.map(|c| c.name.as_str())
.unwrap_or("id");
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {table}.{pk_col_name} (key {row_id} already exists)"
)));
}
OnConflict::Ignore => {
return Ok((0, Vec::new()));
}
OnConflict::Replace => {
self.validate_check_constraints_for_row(&table_def_snapshot, &candidate_row)?;
self.validate_unique_constraints(
pager,
&table_def_snapshot,
&candidate_row,
Some(row_id),
)?;
self.validate_child_foreign_keys(pager, &table_def_snapshot, &candidate_row)?;
if let Ok(old_row) = decode_row(&existing_payload, &all_col_names) {
self.remove_row_from_all_indexes(pager, &table, &old_row, row_id)?;
}
if let Some(index) = self.vector_indexes.get_mut(&table.to_lowercase()) {
index.remove_vector(row_id);
}
self.fts_remove_row(&table_def_snapshot, row_id);
let now_ts = self.next_temporal_timestamp();
self.close_temporal_version(pager, &table, row_id, now_ts)?;
self.btree.delete(pager, root_page, row_id)?;
}
OnConflict::DoUpdate(updates) => {
let old_row = decode_row(&existing_payload, &all_col_names)?;
let mut values: Vec<Value> = old_row.values().to_vec();
for (col_name, new_val) in updates {
if let Some(col_idx) = table_cols
.iter()
.position(|c| c.name.eq_ignore_ascii_case(&col_name))
&& col_idx < values.len()
{
values[col_idx] = new_val;
}
}
for (col_idx, col_def) in table_cols.iter().enumerate() {
if let Some(val) = values.get_mut(col_idx) {
let orig = std::mem::replace(val, Value::Null);
*val = col_def.data_type.coerce_value(orig).map_err(|e| match e {
Error::DimensionMismatch(exp, got) => {
Error::DimensionMismatch(exp, got)
}
Error::ConstraintViolation(msg) => Error::ConstraintViolation(
format!("{table}.{}: {msg}", col_def.name),
),
other => other,
})?;
if col_def.not_null && val.is_null() {
return Err(Error::ConstraintViolation(format!(
"NOT NULL constraint failed: {table}.{}",
col_def.name
)));
}
}
}
let updated_row = Row::new(all_col_names.clone(), values.clone());
self.validate_check_constraints_for_row(&table_def_snapshot, &updated_row)?;
self.validate_unique_constraints(
pager,
&table_def_snapshot,
&updated_row,
Some(row_id),
)?;
self.validate_child_foreign_keys(pager, &table_def_snapshot, &updated_row)?;
self.handle_parent_foreign_key_on_update(
pager,
&table,
&old_row,
&updated_row,
)?;
self.remove_row_from_all_indexes(pager, &table, &old_row, row_id)?;
if let Some(index) = self.vector_indexes.get_mut(&table.to_lowercase()) {
index.remove_vector(row_id);
}
self.fts_remove_row(&table_def_snapshot, row_id);
if is_temporal {
let now_ts = self.next_temporal_timestamp();
self.close_temporal_version(pager, &table, row_id, now_ts)?;
}
self.btree.delete(pager, root_page, row_id)?;
aligned_values = values;
}
}
} else {
self.validate_check_constraints_for_row(&table_def_snapshot, &candidate_row)?;
if let Err(err) =
self.validate_unique_constraints(pager, &table_def_snapshot, &candidate_row, None)
{
if conflict_action == OnConflict::Ignore {
return Ok((0, Vec::new()));
}
return Err(err);
}
self.validate_child_foreign_keys(pager, &table_def_snapshot, &candidate_row)?;
}
let payload = encode_row(&aligned_values);
self.btree.insert(pager, root_page, row_id, &payload)?;
if is_temporal {
let now_ts = self.next_temporal_timestamp();
self.record_temporal_version(pager, &table, row_id, &payload, now_ts, u64::MAX)?;
}
if let Some((v_idx, _)) = vector_col
&& let Some(Value::Vector(vec_data)) = aligned_values.get(v_idx)
{
let index = self
.vector_indexes
.entry(table.to_lowercase())
.or_insert_with(|| HnswIndex::new(vec_data.len(), DistanceMetric::Cosine));
index.insert_vector(row_id, vec_data)?;
}
let final_row = Row::new(all_col_names, aligned_values);
self.add_row_to_all_indexes(pager, &table, &final_row, row_id)?;
self.fts_upsert_row(pager, &table_def_snapshot, &final_row, row_id)?;
self.last_insert_rowid = row_id as i64;
self.fire_triggers(
pager,
&table,
TriggerTiming::After,
TriggerEvent::Insert,
None,
Some(&final_row),
)?;
let returned_rows = if let Some(ref ret_cols) = returning {
if ret_cols.len() == 1 && ret_cols[0] == "*" {
vec![final_row]
} else {
vec![self.project_row(&final_row, ret_cols)?]
}
} else {
Vec::new()
};
Ok((1, returned_rows))
}
fn execute_update(
&mut self,
pager: &mut Pager,
table: String,
assignments: Vec<(String, Value)>,
where_clause: Option<WhereExpr>,
returning: Option<Vec<String>>,
) -> Result<(usize, Vec<Row>)> {
let table_def = self
.catalog
.get_table(&table)
.cloned()
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
let root_page = table_def.root_page;
let all_col_names = table_def.column_names();
for (col_name, _) in &assignments {
if table_def.column_index(col_name).is_none() {
return Err(Error::Corrupted(format!(
"Unknown column in SET: {col_name}"
)));
}
}
let resolved_where = if let Some(ref expr) = where_clause {
Some(self.resolve_where_expr(pager, expr)?)
} else {
None
};
let cells = self.btree.scan(pager, root_page)?;
let mut updated_count = 0;
let mut returned_rows = Vec::new();
for cell in cells {
let full_row = decode_row(&cell.payload, &all_col_names)?;
let matches = if let Some(ref r_expr) = resolved_where {
row_matches_resolved(&full_row, r_expr)
} else {
true
};
if matches {
let mut values: Vec<Value> = full_row.values().to_vec();
for (col_name, new_val) in &assignments {
if let Some(col_idx) = table_def.column_index(col_name)
&& col_idx < values.len()
{
values[col_idx] = new_val.clone();
}
}
for (col_idx, col_def) in table_def.columns.iter().enumerate() {
if let Some(val) = values.get_mut(col_idx) {
let orig = std::mem::replace(val, Value::Null);
*val = col_def.data_type.coerce_value(orig).map_err(|e| match e {
Error::DimensionMismatch(exp, got) => {
Error::DimensionMismatch(exp, got)
}
Error::ConstraintViolation(msg) => Error::ConstraintViolation(format!(
"{table}.{}: {msg}",
col_def.name
)),
other => other,
})?;
}
}
for (col_idx, col_def) in table_def.columns.iter().enumerate() {
if col_def.not_null
&& let Some(val) = values.get(col_idx)
&& val.is_null()
{
return Err(Error::ConstraintViolation(format!(
"NOT NULL constraint failed: {table}.{}",
col_def.name
)));
}
}
let pk_col_idx = table_def.primary_key_index();
let new_row_id = if let Some(pk_idx) = pk_col_idx {
if let Some(Value::Integer(id_val)) = values.get(pk_idx) {
*id_val as u64
} else {
cell.row_id
}
} else {
cell.row_id
};
if new_row_id != cell.row_id
&& let Some(_existing) = self.btree.search(pager, root_page, new_row_id)?
{
let pk_col_name = table_def
.columns
.iter()
.find(|c| c.primary_key)
.map(|c| c.name.as_str())
.unwrap_or("id");
return Err(Error::ConstraintViolation(format!(
"UNIQUE constraint failed: {table}.{pk_col_name} (key {new_row_id} already exists)"
)));
}
let updated_row = Row::new(all_col_names.clone(), values.clone());
if !self.fire_triggers(
pager,
&table,
TriggerTiming::Before,
TriggerEvent::Update,
Some(&full_row),
Some(&updated_row),
)? {
continue;
}
self.validate_check_constraints_for_row(&table_def, &updated_row)?;
self.validate_unique_constraints(
pager,
&table_def,
&updated_row,
Some(cell.row_id),
)?;
self.validate_child_foreign_keys(pager, &table_def, &updated_row)?;
let new_payload = encode_row(&values);
self.btree.delete(pager, root_page, cell.row_id)?;
self.btree
.insert(pager, root_page, new_row_id, &new_payload)?;
self.handle_parent_foreign_key_on_update(pager, &table, &full_row, &updated_row)?;
if table_def.system_versioning || self.default_system_versioning {
let now_ts = self.next_temporal_timestamp();
self.close_temporal_version(pager, &table, cell.row_id, now_ts)?;
self.record_temporal_version(
pager,
&table,
new_row_id,
&new_payload,
now_ts,
u64::MAX,
)?;
}
if let Some((v_idx, _)) = table_def.vector_column() {
if let Some(Value::Vector(vec_data)) = values.get(v_idx) {
let index = self
.vector_indexes
.entry(table.to_lowercase())
.or_insert_with(|| {
HnswIndex::new(vec_data.len(), DistanceMetric::Cosine)
});
index.remove_vector(cell.row_id);
index.insert_vector(new_row_id, vec_data)?;
} else if new_row_id != cell.row_id
&& let Some(index) = self.vector_indexes.get_mut(&table.to_lowercase())
{
index.remove_vector(cell.row_id);
}
}
self.remove_row_from_all_indexes(pager, &table, &full_row, cell.row_id)?;
self.add_row_to_all_indexes(pager, &table, &updated_row, new_row_id)?;
if new_row_id != cell.row_id {
self.fts_remove_row(&table_def, cell.row_id);
}
self.fts_upsert_row(pager, &table_def, &updated_row, new_row_id)?;
if new_row_id >= table_def.next_row_id
&& let Some(tdef_mut) = self.catalog.get_table_mut(&table)
{
tdef_mut.next_row_id = new_row_id + 1;
}
self.fire_triggers(
pager,
&table,
TriggerTiming::After,
TriggerEvent::Update,
Some(&full_row),
Some(&updated_row),
)?;
if let Some(ref ret_cols) = returning {
if ret_cols.len() == 1 && ret_cols[0] == "*" {
returned_rows.push(updated_row);
} else {
returned_rows.push(self.project_row(&updated_row, ret_cols)?);
}
}
updated_count += 1;
}
}
Ok((updated_count, returned_rows))
}
fn execute_delete(
&mut self,
pager: &mut Pager,
table: String,
where_clause: Option<WhereExpr>,
returning: Option<Vec<String>>,
) -> Result<(usize, Vec<Row>)> {
let table_def = self
.catalog
.get_table(&table)
.cloned()
.ok_or_else(|| Error::TableNotFound(table.clone()))?;
let root_page = table_def.root_page;
let all_col_names = table_def.column_names();
let cells = self.btree.scan(pager, root_page)?;
let mut deleted_count = 0;
let mut returned_rows = Vec::new();
let resolved_where = if let Some(ref expr) = where_clause {
Some(self.resolve_where_expr(pager, expr)?)
} else {
None
};
for cell in cells {
let full_row = decode_row(&cell.payload, &all_col_names)?;
let matches = if let Some(ref r_expr) = resolved_where {
row_matches_resolved(&full_row, r_expr)
} else {
true
};
if matches {
if !self.fire_triggers(
pager,
&table,
TriggerTiming::Before,
TriggerEvent::Delete,
Some(&full_row),
None,
)? {
continue;
}
self.handle_parent_foreign_key_on_delete(pager, &table, &full_row)?;
if let Some(ref ret_cols) = returning {
if ret_cols.len() == 1 && ret_cols[0] == "*" {
returned_rows.push(full_row.clone());
} else {
returned_rows.push(self.project_row(&full_row, ret_cols)?);
}
}
self.btree.delete(pager, root_page, cell.row_id)?;
if table_def.system_versioning || self.default_system_versioning {
let now_ts = self.next_temporal_timestamp();
self.close_temporal_version(pager, &table, cell.row_id, now_ts)?;
}
if let Some(index) = self.vector_indexes.get_mut(&table.to_lowercase()) {
index.remove_vector(cell.row_id);
}
self.fts_remove_row(&table_def, cell.row_id);
self.remove_row_from_all_indexes(pager, &table, &full_row, cell.row_id)?;
self.fire_triggers(
pager,
&table,
TriggerTiming::After,
TriggerEvent::Delete,
Some(&full_row),
None,
)?;
deleted_count += 1;
}
}
Ok((deleted_count, returned_rows))
}
}
pub fn sql_like_match(pattern: &str, text: &str) -> bool {
let p_chars: Vec<char> = pattern.to_lowercase().chars().collect();
let t_chars: Vec<char> = text.to_lowercase().chars().collect();
let (p_len, t_len) = (p_chars.len(), t_chars.len());
let mut p_idx = 0;
let mut t_idx = 0;
let mut star_idx = None;
let mut match_idx = 0;
while t_idx < t_len {
if p_idx < p_len && (p_chars[p_idx] == '_' || p_chars[p_idx] == t_chars[t_idx]) {
p_idx += 1;
t_idx += 1;
} else if p_idx < p_len && p_chars[p_idx] == '%' {
star_idx = Some(p_idx);
match_idx = t_idx;
p_idx += 1;
} else if let Some(star) = star_idx {
p_idx = star + 1;
match_idx += 1;
t_idx = match_idx;
} else {
return false;
}
}
while p_idx < p_len && p_chars[p_idx] == '%' {
p_idx += 1;
}
p_idx == p_len
}
pub fn sql_match_bm25(query: &str, text: &str) -> bool {
let query_tokens = crate::memory::bm25::tokenize(query);
if query_tokens.is_empty() {
return false;
}
let text_tokens: std::collections::HashSet<String> =
crate::memory::bm25::tokenize(text).into_iter().collect();
query_tokens.iter().any(|token| text_tokens.contains(token))
}
pub fn matches_condition(actual: &Value, op: &BinaryOp, target: &Value) -> bool {
match op {
BinaryOp::IsNull => return actual.is_null(),
BinaryOp::IsNotNull => return !actual.is_null(),
_ => {}
}
if actual.is_null() || target.is_null() {
return false;
}
match op {
BinaryOp::Equals => actual == target,
BinaryOp::NotEquals => actual != target,
BinaryOp::GreaterThan => actual.compare(target) == std::cmp::Ordering::Greater,
BinaryOp::LessThan => actual.compare(target) == std::cmp::Ordering::Less,
BinaryOp::GreaterOrEqual => {
let ord = actual.compare(target);
ord == std::cmp::Ordering::Greater || ord == std::cmp::Ordering::Equal
}
BinaryOp::LessOrEqual => {
let ord = actual.compare(target);
ord == std::cmp::Ordering::Less || ord == std::cmp::Ordering::Equal
}
BinaryOp::Like => match (actual, target) {
(Value::Text(txt), Value::Text(pat)) => sql_like_match(pat, txt),
_ => false,
},
BinaryOp::NotLike => match (actual, target) {
(Value::Text(txt), Value::Text(pat)) => !sql_like_match(pat, txt),
_ => false,
},
BinaryOp::Match => match (actual, target) {
(Value::Text(txt), Value::Text(q)) => sql_match_bm25(q, txt),
_ => false,
},
BinaryOp::IsNull | BinaryOp::IsNotNull => unreachable!(),
}
}
pub fn row_matches_resolved(row: &Row, expr: &ResolvedWhereExpr) -> bool {
row_matches_resolved_with_udf(row, expr, None)
}
pub fn row_matches_resolved_with_udf(
row: &Row,
expr: &ResolvedWhereExpr,
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> bool {
match expr {
ResolvedWhereExpr::Boolean(b) => *b,
ResolvedWhereExpr::Condition(cond) => {
let val = match row.get_field_or_json_path(&cond.column) {
Some(v) => v.clone(),
None => {
if let Ok(Some(fn_v)) = try_eval_scalar_expr(row, &cond.column, udfs) {
fn_v
} else {
return false;
}
}
};
matches_condition(&val, &cond.op, &cond.value)
}
ResolvedWhereExpr::And(left, right) => {
row_matches_resolved_with_udf(row, left, udfs)
&& row_matches_resolved_with_udf(row, right, udfs)
}
ResolvedWhereExpr::Or(left, right) => {
row_matches_resolved_with_udf(row, left, udfs)
|| row_matches_resolved_with_udf(row, right, udfs)
}
ResolvedWhereExpr::InList {
column,
values,
negated,
} => {
let val = match row.get_field_or_json_path(column) {
Some(v) => v.clone(),
None => {
if let Ok(Some(fn_v)) = try_eval_scalar_expr(row, column, udfs) {
fn_v
} else {
return false;
}
}
};
if val.is_null() {
return false;
}
let has_null = values.iter().any(|v| v.is_null());
let in_list = values.iter().any(|target| val.compare(target).is_eq());
if *negated {
if has_null { false } else { !in_list }
} else {
in_list
}
}
}
}
pub fn row_matches_conditions(row: &Row, conditions: &[WhereCondition]) -> bool {
for cond in conditions {
let val = match row.get_field_or_json_path(&cond.column) {
Some(v) => v,
None => return false,
};
if !matches_condition(&val, &cond.op, &cond.value) {
return false;
}
}
true
}
fn parse_col_and_alias(col: &str) -> (&str, Option<&str>) {
let trimmed = col.trim();
if let Some(pos) = trimmed.to_ascii_uppercase().rfind(" AS ") {
let expr = trimmed[..pos].trim();
let alias = trimmed[pos + 4..].trim();
if !alias.is_empty() {
return (expr, Some(alias));
}
}
(trimmed, None)
}
fn has_window_function(col: &str) -> bool {
let u = col.to_ascii_uppercase();
u.contains(" OVER ") || u.contains(" OVER(")
}
#[derive(Debug, Clone)]
struct ParsedWindowCol {
raw: String,
expr: String,
alias: Option<String>,
func: String,
arg: String,
offset: usize,
partition_by: Vec<String>,
order_by: Option<(String, bool)>,
}
fn parse_window_function(col_str: &str) -> Option<ParsedWindowCol> {
let (expr, alias) = parse_col_and_alias(col_str);
let u = expr.to_ascii_uppercase();
let over_pos = u.find(" OVER ").or_else(|| u.find(" OVER("))?;
let func_part = expr[..over_pos].trim();
let open_p = func_part.find('(')?;
let close_p = func_part.rfind(')')?;
let func = func_part[..open_p].trim().to_ascii_uppercase();
let arg_inner = func_part[open_p + 1..close_p].trim();
let mut arg = arg_inner.to_string();
let mut offset = 1usize;
if func == "LAG" || func == "LEAD" {
if let Some(comma) = arg_inner.find(',') {
arg = arg_inner[..comma].trim().to_string();
let off_str = arg_inner[comma + 1..].trim();
if let Ok(n) = off_str.parse::<usize>() {
offset = n;
}
}
} else if func == "NTILE"
&& let Ok(n) = arg_inner.parse::<usize>()
{
offset = n.max(1);
}
let spec_part = &expr[over_pos..];
let spec_open = spec_part.find('(')?;
let spec_close = spec_part.rfind(')')?;
let spec_inner = spec_part[spec_open + 1..spec_close].trim();
let spec_u = spec_inner.to_ascii_uppercase();
let mut partition_by = Vec::new();
let mut order_by = None;
if let Some(p_idx) = spec_u.find("PARTITION BY") {
let after_p = spec_inner[p_idx + 12..].trim();
let end_p = after_p
.to_ascii_uppercase()
.find("ORDER BY")
.unwrap_or(after_p.len());
let p_cols_str = after_p[..end_p].trim();
for c in p_cols_str.split(',') {
let trimmed = c.trim();
if !trimmed.is_empty() {
partition_by.push(trimmed.to_string());
}
}
}
if let Some(o_idx) = spec_u.find("ORDER BY") {
let after_o = spec_inner[o_idx + 8..].trim();
let parts: Vec<&str> = after_o.split_whitespace().collect();
if !parts.is_empty() {
let col = parts[0].trim().to_string();
let is_asc = !(parts.len() > 1 && parts[1].eq_ignore_ascii_case("DESC"));
order_by = Some((col, is_asc));
}
}
Some(ParsedWindowCol {
raw: col_str.to_string(),
expr: expr.to_string(),
alias: alias.map(|s| s.to_string()),
func,
arg,
offset,
partition_by,
order_by,
})
}
fn evaluate_window_functions(rows: &mut [Row], columns: &[String]) -> Result<()> {
if rows.is_empty() {
return Ok(());
}
let n_rows = rows.len();
for col in columns {
if let Some(w) = parse_window_function(col) {
let mut partitions: HashMap<Vec<String>, Vec<usize>> = HashMap::new();
for (i, r) in rows.iter().enumerate() {
let mut key = Vec::new();
for p_col in &w.partition_by {
let v = format!("{:?}", r.get_value(p_col).unwrap_or(&Value::Null));
key.push(v);
}
partitions.entry(key).or_default().push(i);
}
let mut computed_values: Vec<(usize, Value)> = Vec::with_capacity(n_rows);
for (_key, mut p_indices) in partitions {
if let Some((ref o_col, is_asc)) = w.order_by {
p_indices.sort_by(|&a_idx, &b_idx| {
let val_a = rows[a_idx].get_value(o_col).unwrap_or(&Value::Null);
let val_b = rows[b_idx].get_value(o_col).unwrap_or(&Value::Null);
if is_asc {
val_a.compare(val_b)
} else {
val_b.compare(val_a)
}
});
}
let p_len = p_indices.len();
let mut prev_order_val: Option<Value> = None;
let mut current_rank = 1usize;
let mut current_dense_rank = 1usize;
for (pos, &row_idx) in p_indices.iter().enumerate() {
let computed_val = match w.func.as_str() {
"ROW_NUMBER" => Value::Integer((pos + 1) as i64),
"RANK" => {
if let Some((ref o_col, _)) = w.order_by {
let cur_val = rows[row_idx]
.get_value(o_col)
.cloned()
.unwrap_or(Value::Null);
if pos > 0
&& let Some(ref prev) = prev_order_val
&& prev != &cur_val
{
current_rank = pos + 1;
}
prev_order_val = Some(cur_val);
} else {
current_rank = pos + 1;
}
Value::Integer(current_rank as i64)
}
"DENSE_RANK" => {
if let Some((ref o_col, _)) = w.order_by {
let cur_val = rows[row_idx]
.get_value(o_col)
.cloned()
.unwrap_or(Value::Null);
if pos > 0
&& let Some(ref prev) = prev_order_val
&& prev != &cur_val
{
current_dense_rank += 1;
}
prev_order_val = Some(cur_val);
} else {
current_dense_rank = pos + 1;
}
Value::Integer(current_dense_rank as i64)
}
"NTILE" => {
let k = w.offset.max(1);
let bucket = (pos * k) / p_len.max(1) + 1;
Value::Integer(bucket as i64)
}
"LAG" => {
if pos >= w.offset {
let target_row_idx = p_indices[pos - w.offset];
rows[target_row_idx]
.get_value(&w.arg)
.cloned()
.unwrap_or(Value::Null)
} else {
Value::Null
}
}
"LEAD" => {
if pos + w.offset < p_len {
let target_row_idx = p_indices[pos + w.offset];
rows[target_row_idx]
.get_value(&w.arg)
.cloned()
.unwrap_or(Value::Null)
} else {
Value::Null
}
}
"COUNT" => {
let is_count_all = w.arg == "*" || w.arg == "1" || w.arg.is_empty();
if is_count_all {
Value::Integer(p_len as i64)
} else {
let mut count = 0i64;
for &idx in &p_indices {
if let Some(v) = rows[idx].get_value(&w.arg)
&& v != &Value::Null
{
count += 1;
}
}
Value::Integer(count)
}
}
"SUM" => {
let mut sum = 0.0f64;
let mut is_int = true;
let mut int_sum = 0i64;
for &idx in &p_indices {
match rows[idx].get_value(&w.arg) {
Some(Value::Integer(i)) => {
int_sum += *i;
sum += *i as f64;
}
Some(Value::Real(f)) => {
is_int = false;
sum += *f;
}
_ => {}
}
}
if is_int {
Value::Integer(int_sum)
} else {
Value::Real(sum)
}
}
"AVG" => {
let mut sum = 0.0f64;
let mut count = 0usize;
for &idx in &p_indices {
match rows[idx].get_value(&w.arg) {
Some(Value::Integer(i)) => {
sum += *i as f64;
count += 1;
}
Some(Value::Real(f)) => {
sum += *f;
count += 1;
}
_ => {}
}
}
if count > 0 {
Value::Real(sum / count as f64)
} else {
Value::Null
}
}
"MIN" => {
let mut min_val: Option<Value> = None;
for &idx in &p_indices {
if let Some(v) = rows[idx].get_value(&w.arg)
&& v != &Value::Null
&& (min_val.is_none()
|| min_val
.as_ref()
.map(|m| v.compare(m).is_lt())
.unwrap_or(false))
{
min_val = Some(v.clone());
}
}
min_val.unwrap_or(Value::Null)
}
"MAX" => {
let mut max_val: Option<Value> = None;
for &idx in &p_indices {
if let Some(v) = rows[idx].get_value(&w.arg)
&& v != &Value::Null
&& (max_val.is_none()
|| max_val
.as_ref()
.map(|m| v.compare(m).is_gt())
.unwrap_or(false))
{
max_val = Some(v.clone());
}
}
max_val.unwrap_or(Value::Null)
}
_ => Value::Null,
};
computed_values.push((row_idx, computed_val));
}
}
for (row_idx, val) in computed_values {
rows[row_idx].push_column(w.expr.clone(), val.clone());
rows[row_idx].push_column(w.raw.clone(), val.clone());
if let Some(ref al) = w.alias {
rows[row_idx].push_column(al.clone(), val);
}
}
}
}
Ok(())
}
pub fn project_row(row: &Row, requested_cols: &[String]) -> Result<Row> {
project_row_with_udf(row, requested_cols, None)
}
pub fn project_row_with_udf(
row: &Row,
requested_cols: &[String],
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> Result<Row> {
let mut names = Vec::with_capacity(requested_cols.len());
let mut vals = Vec::with_capacity(requested_cols.len());
for col in requested_cols {
let (expr, alias) = parse_col_and_alias(col);
let val = if let Some(fn_val) = try_eval_scalar_expr(row, expr, udfs)? {
fn_val
} else if (expr.starts_with('\'') && expr.ends_with('\''))
|| expr.parse::<f64>().is_ok()
|| expr.eq_ignore_ascii_case("NULL")
{
eval_func_arg(row, expr, udfs)?
} else {
row.get_field_or_json_path(expr)
.or_else(|| row.get_field_or_json_path(col))
.or_else(|| row.get_value(expr).cloned())
.unwrap_or(Value::Null)
};
names.push(alias.unwrap_or(expr).to_string());
vals.push(val);
}
Ok(Row::new(names, vals))
}
fn split_func_args(inner: &str) -> Vec<&str> {
if inner.trim().is_empty() {
return Vec::new();
}
let mut args = Vec::new();
let mut cur_start = 0;
let mut in_single_quote = false;
let mut in_double_quote = false;
let mut bracket_depth: u32 = 0;
for (idx, ch) in inner.char_indices() {
match ch {
'\'' if !in_double_quote => in_single_quote = !in_single_quote,
'"' if !in_single_quote => in_double_quote = !in_double_quote,
'[' if !in_single_quote && !in_double_quote => bracket_depth += 1,
']' if !in_single_quote && !in_double_quote => {
bracket_depth = bracket_depth.saturating_sub(1)
}
',' if !in_single_quote && !in_double_quote && bracket_depth == 0 => {
args.push(inner[cur_start..idx].trim());
cur_start = idx + 1;
}
_ => {}
}
}
args.push(inner[cur_start..].trim());
args
}
fn eval_func_arg(
row: &Row,
raw: &str,
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> Result<Value> {
let trimmed = raw.trim();
if trimmed.is_empty() {
return Ok(Value::Null);
}
if (trimmed.starts_with('\'') && trimmed.ends_with('\''))
|| (trimmed.starts_with('"') && trimmed.ends_with('"'))
{
return Ok(Value::Text(strip_quotes(trimmed).replace("''", "'")));
}
let upper = trimmed.to_ascii_uppercase();
if upper == "NULL" {
return Ok(Value::Null);
}
if upper == "TRUE" {
return Ok(Value::Integer(1));
}
if upper == "FALSE" {
return Ok(Value::Integer(0));
}
if let Ok(i) = trimmed.parse::<i64>() {
return Ok(Value::Integer(i));
}
if let Ok(f) = trimmed.parse::<f64>() {
return Ok(Value::Real(f));
}
if let Some(val) = try_eval_scalar_expr(row, trimmed, udfs)? {
return Ok(val);
}
if let Some(val) = row
.get_field_or_json_path(trimmed)
.or_else(|| row.get_value(trimmed).cloned())
{
return Ok(val);
}
Ok(Value::Text(trimmed.to_string()))
}
fn strip_outer_parens(expr: &str) -> &str {
let mut s = expr.trim();
while s.starts_with('(') && s.ends_with(')') {
let mut depth = 0usize;
let mut in_sq = false;
let mut in_dq = false;
let mut wraps_entire = true;
for (idx, ch) in s.char_indices() {
match ch {
'\'' if !in_dq => in_sq = !in_sq,
'"' if !in_sq => in_dq = !in_dq,
'(' if !in_sq && !in_dq => depth += 1,
')' if !in_sq && !in_dq => {
depth = depth.saturating_sub(1);
if depth == 0 && idx + 1 < s.len() {
wraps_entire = false;
break;
}
}
_ => {}
}
}
if wraps_entire && depth == 0 {
s = s[1..s.len() - 1].trim();
} else {
break;
}
}
s
}
#[derive(Copy, Clone, PartialEq, Eq)]
enum InfixOp {
Concat,
Add,
Sub,
Mul,
Div,
Mod,
}
fn find_top_level_infix(expr: &str) -> Option<(usize, usize, InfixOp)> {
let bytes = expr.as_bytes();
let mut depth_paren = 0usize;
let mut depth_bracket = 0usize;
let mut in_sq = false;
let mut in_dq = false;
let mut tier1: Option<(usize, usize, InfixOp)> = None; let mut tier2: Option<(usize, usize, InfixOp)> = None; let mut tier3: Option<(usize, usize, InfixOp)> = None;
let mut i = 0usize;
while i < bytes.len() {
let b = bytes[i];
match b {
b'\'' if !in_dq => in_sq = !in_sq,
b'"' if !in_sq => in_dq = !in_dq,
b'(' if !in_sq && !in_dq => depth_paren += 1,
b')' if !in_sq && !in_dq => depth_paren = depth_paren.saturating_sub(1),
b'[' if !in_sq && !in_dq => depth_bracket += 1,
b']' if !in_sq && !in_dq => depth_bracket = depth_bracket.saturating_sub(1),
_ if !in_sq && !in_dq && depth_paren == 0 && depth_bracket == 0 => {
if b == b'|' && i + 1 < bytes.len() && bytes[i + 1] == b'|' {
tier1 = Some((i, 2, InfixOp::Concat));
i += 2;
continue;
} else if b == b'+' {
tier2 = Some((i, 1, InfixOp::Add));
} else if b == b'-' {
let prev_non_ws = expr[..i].trim_end().as_bytes().last().copied();
let is_binary = matches!(
prev_non_ws,
Some(c) if c.is_ascii_alphanumeric() || matches!(c, b'_' | b')' | b'\'' | b'"')
);
if is_binary {
tier2 = Some((i, 1, InfixOp::Sub));
}
} else if b == b'*' && !expr[..i].trim().is_empty() {
tier3 = Some((i, 1, InfixOp::Mul));
} else if b == b'/' {
tier3 = Some((i, 1, InfixOp::Div));
} else if b == b'%' {
tier3 = Some((i, 1, InfixOp::Mod));
}
}
_ => {}
}
i += 1;
}
tier1.or(tier2).or(tier3)
}
fn eval_infix_expr(
row: &Row,
expr: &str,
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> Result<Option<Value>> {
let trimmed = strip_outer_parens(expr);
let Some((pos, len, op)) = find_top_level_infix(trimmed) else {
return Ok(None);
};
let lhs_raw = trimmed[..pos].trim();
let rhs_raw = trimmed[pos + len..].trim();
if lhs_raw.is_empty() || rhs_raw.is_empty() {
return Ok(None);
}
let lhs = eval_func_arg(row, lhs_raw, udfs)?;
let rhs = eval_func_arg(row, rhs_raw, udfs)?;
if matches!(lhs, Value::Null) || matches!(rhs, Value::Null) {
return Ok(Some(Value::Null));
}
let result = match op {
InfixOp::Concat => Value::Text(format!(
"{}{}",
value_to_concat_str(&lhs),
value_to_concat_str(&rhs)
)),
InfixOp::Add => match (lhs, rhs) {
(Value::Integer(a), Value::Integer(b)) => a
.checked_add(b)
.map(Value::Integer)
.unwrap_or_else(|| Value::Real(a as f64 + b as f64)),
(a, b) => match (as_f64(&a), as_f64(&b)) {
(Some(x), Some(y)) => Value::Real(x + y),
_ => Value::Null,
},
},
InfixOp::Sub => match (lhs, rhs) {
(Value::Integer(a), Value::Integer(b)) => a
.checked_sub(b)
.map(Value::Integer)
.unwrap_or_else(|| Value::Real(a as f64 - b as f64)),
(a, b) => match (as_f64(&a), as_f64(&b)) {
(Some(x), Some(y)) => Value::Real(x - y),
_ => Value::Null,
},
},
InfixOp::Mul => match (lhs, rhs) {
(Value::Integer(a), Value::Integer(b)) => a
.checked_mul(b)
.map(Value::Integer)
.unwrap_or_else(|| Value::Real(a as f64 * b as f64)),
(a, b) => match (as_f64(&a), as_f64(&b)) {
(Some(x), Some(y)) => Value::Real(x * y),
_ => Value::Null,
},
},
InfixOp::Div => match (lhs, rhs) {
(Value::Integer(_), Value::Integer(0)) => Value::Null,
(Value::Integer(a), Value::Integer(b)) => Value::Integer(a / b),
(a, b) => match (as_f64(&a), as_f64(&b)) {
(Some(_), Some(0.0)) => Value::Null,
(Some(x), Some(y)) => Value::Real(x / y),
_ => Value::Null,
},
},
InfixOp::Mod => match (lhs, rhs) {
(Value::Integer(_), Value::Integer(0)) => Value::Null,
(Value::Integer(a), Value::Integer(b)) => Value::Integer(a % b),
(a, b) => match (as_f64(&a), as_f64(&b)) {
(Some(_), Some(0.0)) => Value::Null,
(Some(x), Some(y)) => Value::Real(x % y),
_ => Value::Null,
},
},
};
Ok(Some(result))
}
fn as_f64(val: &Value) -> Option<f64> {
match val {
Value::Integer(i) => Some(*i as f64),
Value::Real(f) => Some(*f),
Value::Text(s) => s.trim().parse::<f64>().ok(),
_ => None,
}
}
fn value_to_concat_str(val: &Value) -> String {
match val {
Value::Text(s) => s.clone(),
Value::Integer(i) => i.to_string(),
Value::Real(f) => f.to_string(),
other => other.to_string(),
}
}
pub fn try_eval_scalar_expr(
row: &Row,
expr: &str,
udfs: Option<&crate::sql::udf::UdfRegistry>,
) -> Result<Option<Value>> {
let trimmed = strip_outer_parens(expr);
if let Some(infix_val) = eval_infix_expr(row, trimmed, udfs)? {
return Ok(Some(infix_val));
}
if !trimmed.contains('(') || !trimmed.ends_with(')') {
return Ok(None);
}
if let Some(tap_val) = try_eval_tap_function(row, trimmed)? {
return Ok(Some(tap_val));
}
let paren_idx = match trimmed.find('(') {
Some(idx) => idx,
None => return Ok(None),
};
let func_name = trimmed[..paren_idx].trim();
let inner = trimmed[paren_idx + 1..trimmed.len() - 1].trim();
let raw_args = split_func_args(inner);
let mut evaluated_args = Vec::with_capacity(raw_args.len());
for raw_arg in raw_args {
evaluated_args.push(eval_func_arg(row, raw_arg, udfs)?);
}
if let Some(registry) = udfs
&& let Some(res) = registry.try_call(func_name, &evaluated_args)?
{
return Ok(Some(res));
}
let standard = crate::sql::udf::UdfRegistry::new();
if let Some(res) = standard.try_call(func_name, &evaluated_args)? {
return Ok(Some(res));
}
Ok(None)
}
fn try_eval_tap_function(row: &Row, expr: &str) -> Result<Option<Value>> {
let trimmed = expr.trim();
let upper = trimmed.to_ascii_uppercase();
let (func_type, rest) = if upper.starts_with("TAP_CLASSIFY_GROUNDED(") {
("CLASSIFY_GROUNDED", &trimmed[22..])
} else if upper.starts_with("TAP_VERIFY_GROUNDED(") {
("VERIFY_GROUNDED", &trimmed[20..])
} else if upper.starts_with("TAP_CLASSIFY(") {
("CLASSIFY", &trimmed[13..])
} else if upper.starts_with("TAP_SCORE(") {
("SCORE", &trimmed[10..])
} else if upper.starts_with("TAP_VERIFY(") {
("VERIFY", &trimmed[11..])
} else if upper.starts_with("TAP_ROUTE(") {
("ROUTE", &trimmed[10..])
} else if upper.starts_with("VECTOR_COSINE(") {
("VECTOR_COSINE", &trimmed[14..])
} else if upper.starts_with("VECTOR_L2(") {
("VECTOR_L2", &trimmed[10..])
} else if upper.starts_with("VECTOR_DISTANCE(") {
("VECTOR_L2", &trimmed[16..])
} else {
return Ok(None);
};
if !rest.ends_with(')') {
return Ok(None);
}
let inner = rest[..rest.len() - 1].trim();
let mut args = Vec::new();
let mut cur_start = 0;
let mut in_single_quote = false;
let mut in_double_quote = false;
let mut bracket_depth: u32 = 0;
for (idx, ch) in inner.char_indices() {
match ch {
'\'' if !in_double_quote => in_single_quote = !in_single_quote,
'"' if !in_single_quote => in_double_quote = !in_double_quote,
'[' if !in_single_quote && !in_double_quote => bracket_depth += 1,
']' if !in_single_quote && !in_double_quote => {
bracket_depth = bracket_depth.saturating_sub(1)
}
',' if !in_single_quote && !in_double_quote && bracket_depth == 0 => {
args.push(inner[cur_start..idx].trim());
cur_start = idx + 1;
}
_ => {}
}
}
args.push(inner[cur_start..].trim());
let raw_arg1 = args.first().copied().unwrap_or("");
let raw_arg2 = args.get(1).copied().unwrap_or("");
let arg1_val = if let Some(v) = row
.get_field_or_json_path(raw_arg1)
.or_else(|| row.get_value(raw_arg1).cloned())
{
match v {
Value::Text(s) => s.clone(),
other => other.to_string(),
}
} else {
strip_quotes(raw_arg1).to_string()
};
let arg2_val = strip_quotes(raw_arg2);
match func_type {
"VECTOR_COSINE" => {
let vec1 = resolve_vector_arg(row, raw_arg1)?;
let vec2 = resolve_vector_arg(row, raw_arg2)?;
let sim = crate::vector::cosine_similarity(&vec1, &vec2);
Ok(Some(Value::Real(sim as f64)))
}
"VECTOR_L2" => {
let vec1 = resolve_vector_arg(row, raw_arg1)?;
let vec2 = resolve_vector_arg(row, raw_arg2)?;
let dist = crate::vector::euclidean_distance(&vec1, &vec2);
Ok(Some(Value::Real(dist as f64)))
}
"CLASSIFY_GROUNDED" => {
let index_name = args.get(2).map(|s| strip_quotes(s)).unwrap_or("default");
let top_k = args
.get(3)
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(3);
let label = crate::tap::sql_bridge::eval_tap_classify_grounded(
&arg1_val, arg2_val, index_name, top_k,
)?;
Ok(Some(Value::Text(label)))
}
"VERIFY_GROUNDED" => {
let index_name = args.get(2).map(|s| strip_quotes(s)).unwrap_or("default");
let top_k = args
.get(3)
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(3);
let verified = crate::tap::sql_bridge::eval_tap_verify_grounded(
&arg1_val, arg2_val, index_name, top_k,
)?;
Ok(Some(Value::Integer(if verified { 1 } else { 0 })))
}
"CLASSIFY" => {
let label = crate::tap::sql_bridge::eval_tap_classify(&arg1_val, arg2_val)?;
Ok(Some(Value::Text(label)))
}
"SCORE" => {
let score = crate::tap::sql_bridge::eval_tap_score(&arg1_val, arg2_val)?;
Ok(Some(Value::Real(score as f64)))
}
"VERIFY" => {
let verified = crate::tap::sql_bridge::eval_tap_verify(&arg1_val, arg2_val)?;
Ok(Some(Value::Integer(if verified { 1 } else { 0 })))
}
"ROUTE" => {
let route = crate::tap::sql_bridge::eval_tap_route(&arg1_val, arg2_val)?;
Ok(Some(Value::Text(route)))
}
_ => Ok(None),
}
}
fn resolve_vector_arg(row: &Row, raw_arg: &str) -> Result<Vec<f32>> {
let trimmed = raw_arg.trim();
if trimmed.starts_with('[') && trimmed.ends_with(']') {
let inner = &trimmed[1..trimmed.len() - 1];
let mut vec = Vec::new();
for item in inner.split(',') {
let item_t = item.trim();
if !item_t.is_empty()
&& let Ok(f) = item_t.parse::<f32>()
{
vec.push(f);
}
}
Ok(vec)
} else if let Some(val) = row
.get_field_or_json_path(trimmed)
.or_else(|| row.get_value(trimmed).cloned())
{
match val {
Value::Vector(v) => Ok(v),
_ => Err(Error::ConstraintViolation(format!(
"Argument '{trimmed}' is not a vector"
))),
}
} else {
Err(Error::ConstraintViolation(format!(
"Could not resolve vector argument '{trimmed}'"
)))
}
}
fn strip_quotes(s: &str) -> &str {
let trimmed = s.trim();
if ((trimmed.starts_with('\'') && trimmed.ends_with('\''))
|| (trimmed.starts_with('"') && trimmed.ends_with('"')))
&& trimmed.len() >= 2
{
return &trimmed[1..trimmed.len() - 1];
}
trimmed
}
#[derive(Debug, Clone)]
struct ParsedAggSpec {
output_name: String,
func: String,
arg: String,
percentile_q: Option<f64>,
is_star: bool,
is_distinct: bool,
}
impl ParsedAggSpec {
fn needs_samples(&self) -> bool {
matches!(
self.func.as_str(),
"MEDIAN" | "PERCENTILE" | "PERCENTILE_CONT"
)
}
fn needs_distinct(&self) -> bool {
self.is_distinct
}
fn finalize(&self, acc: &mut crate::sql::vectorized::VectorizedAccumulator) -> Value {
match self.func.as_str() {
"COUNT" if self.is_distinct => acc.finalize_count_distinct(),
"COUNT" => acc.finalize_count(self.is_star),
"SUM" => acc.finalize_sum(),
"AVG" => acc.finalize_avg(),
"MIN" => acc.finalize_min(),
"MAX" => acc.finalize_max(),
"STDDEV" | "STDDEV_SAMP" | "STDEV" => acc.finalize_stddev(true),
"STDDEV_POP" => acc.finalize_stddev(false),
"VARIANCE" | "VAR_SAMP" => acc.finalize_variance(true),
"VAR_POP" => acc.finalize_variance(false),
"MEDIAN" => acc.finalize_median(),
"PERCENTILE" | "PERCENTILE_CONT" => {
acc.finalize_percentile(self.percentile_q.unwrap_or(0.5))
}
_ => Value::Null,
}
}
}
fn parse_aggregate_spec(col: &str) -> Option<ParsedAggSpec> {
let (expr, alias_opt) = parse_col_and_alias(col);
let expr_upper = expr.to_ascii_uppercase();
if expr_upper.contains(" OVER ") || expr_upper.contains(" OVER(") {
return None;
}
let open_p = expr.find('(')?;
let close_p = expr.rfind(')')?;
if close_p <= open_p {
return None;
}
let func = expr[..open_p].trim().to_ascii_uppercase();
if !matches!(
func.as_str(),
"COUNT"
| "SUM"
| "AVG"
| "MIN"
| "MAX"
| "STDDEV"
| "STDDEV_SAMP"
| "STDDEV_POP"
| "STDEV"
| "VARIANCE"
| "VAR_SAMP"
| "VAR_POP"
| "MEDIAN"
| "PERCENTILE"
| "PERCENTILE_CONT"
) {
return None;
}
let raw_arg = expr[open_p + 1..close_p].trim();
let (arg_part, percentile_q) = if matches!(func.as_str(), "PERCENTILE" | "PERCENTILE_CONT")
&& let Some((col_part, q_part)) = raw_arg.split_once(',')
{
(col_part.trim(), q_part.trim().parse::<f64>().ok())
} else {
(raw_arg, None)
};
let mut is_distinct = false;
let cleaned_arg =
if func == "COUNT" && arg_part.len() > 9 && arg_part[..9].eq_ignore_ascii_case("DISTINCT ")
{
is_distinct = true;
arg_part[9..].trim()
} else {
arg_part
};
let is_star = !is_distinct
&& (cleaned_arg == "*"
|| cleaned_arg == "1"
|| (!cleaned_arg.is_empty() && cleaned_arg.chars().all(|c| c.is_ascii_digit())));
let output_name = alias_opt.unwrap_or(expr).to_string();
Some(ParsedAggSpec {
output_name,
func,
arg: cleaned_arg.to_string(),
percentile_q,
is_star,
is_distinct,
})
}
fn is_aggregate_query(columns: &[String]) -> bool {
columns.iter().any(|c| parse_aggregate_spec(c).is_some())
}
fn compute_aggregate_from_spec(spec: &ParsedAggSpec, rows: &[Row]) -> Value {
if spec.func == "COUNT" && spec.is_star {
return Value::Integer(rows.len() as i64);
}
let mut acc = crate::sql::vectorized::VectorizedAccumulator::with_tracking(
spec.needs_samples(),
spec.needs_distinct(),
);
for r in rows {
if let Some(v) = r.get_value(&spec.arg) {
acc.accumulate_value(v);
}
}
spec.finalize(&mut acc)
}
fn aggregate_ephemeral_rows(
rows: &[Row],
columns: &[String],
gb_cols: &[String],
resolved_having: Option<&ResolvedWhereExpr>,
) -> Vec<Row> {
let mut group_map: HashMap<Vec<HashableValue>, usize> = HashMap::new();
let mut groups: Vec<(Vec<Value>, Vec<&Row>)> = Vec::new();
for row in rows {
let key: Vec<Value> = gb_cols
.iter()
.map(|c| row.get_value(c).cloned().unwrap_or(Value::Null))
.collect();
let hash_key: Vec<HashableValue> = key.iter().map(HashableValue::from).collect();
if let Some(&pos) = group_map.get(&hash_key) {
groups[pos].1.push(row);
} else {
let pos = groups.len();
group_map.insert(hash_key, pos);
groups.push((key, vec![row]));
}
}
let output_cols = if columns.is_empty() {
gb_cols.to_vec()
} else {
columns.to_vec()
};
let mut grouped_rows = Vec::with_capacity(groups.len());
for (key, g_rows) in groups {
let mut g_cols = Vec::with_capacity(output_cols.len());
let mut g_vals = Vec::with_capacity(output_cols.len());
for col in &output_cols {
if let Some(spec) = parse_aggregate_spec(col) {
if spec.func == "COUNT" && spec.is_star {
g_cols.push(spec.output_name);
g_vals.push(Value::Integer(g_rows.len() as i64));
} else {
let mut acc = crate::sql::vectorized::VectorizedAccumulator::with_tracking(
spec.needs_samples(),
spec.needs_distinct(),
);
for r in &g_rows {
if let Some(v) = r.get_value(&spec.arg) {
acc.accumulate_value(v);
}
}
let val = spec.finalize(&mut acc);
g_cols.push(spec.output_name);
g_vals.push(val);
}
continue;
}
let (raw_col, alias_opt) = parse_col_and_alias(col);
let out_name = alias_opt.unwrap_or(raw_col).to_string();
if let Some(pos) = gb_cols.iter().position(|c| c.eq_ignore_ascii_case(raw_col)) {
g_cols.push(out_name);
g_vals.push(key[pos].clone());
} else {
let val = g_rows
.first()
.and_then(|r| r.get_value(raw_col))
.cloned()
.unwrap_or(Value::Null);
g_cols.push(out_name);
g_vals.push(val);
}
}
let g_row = Row::new(g_cols, g_vals);
if let Some(h_expr) = resolved_having
&& !row_matches_resolved(&g_row, h_expr)
{
continue;
}
grouped_rows.push(g_row);
}
grouped_rows
}
#[cfg(test)]
mod tests {
use super::*;
use crate::sql::parser::parse_sql;
#[test]
fn test_executor_create_insert_select_and_vector() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
let create_sql =
"CREATE TABLE articles (id INTEGER PRIMARY KEY, title TEXT, embedding VECTOR(3));";
let res = executor
.execute(&mut pager, parse_sql(create_sql).unwrap())
.expect("Execute CREATE TABLE");
assert_eq!(res, 1);
executor
.execute(
&mut pager,
parse_sql("INSERT INTO articles (id, title, embedding) VALUES (1, 'Safe Rust Systems', [1.0, 0.0, 0.0]);").unwrap(),
)
.expect("Insert 1");
executor
.execute(
&mut pager,
parse_sql("INSERT INTO articles (id, title, embedding) VALUES (2, 'AI Database Engines', [0.0, 1.0, 0.0]);").unwrap(),
)
.expect("Insert 2");
let rows = executor
.query(
&mut pager,
parse_sql("SELECT id, title FROM articles;").unwrap(),
)
.expect("Query all");
assert_eq!(rows.len(), 2);
assert_eq!(rows[0].get::<i64>("id").unwrap(), 1);
assert_eq!(rows[0].get::<String>("title").unwrap(), "Safe Rust Systems");
let point_rows = executor
.query(
&mut pager,
parse_sql("SELECT title FROM articles WHERE id = 2;").unwrap(),
)
.expect("Query point");
assert_eq!(point_rows.len(), 1);
assert_eq!(
point_rows[0].get::<String>("title").unwrap(),
"AI Database Engines"
);
let vector_rows = executor
.query(
&mut pager,
parse_sql("SELECT id, title FROM articles VECTOR NEAR embedding = [0.95, 0.05, 0.0] TOP 1;").unwrap(),
)
.expect("Vector search");
assert_eq!(vector_rows.len(), 1);
assert_eq!(
vector_rows[0].get::<String>("title").unwrap(),
"Safe Rust Systems"
);
}
#[test]
fn test_executor_order_by_aggregates_and_join() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor
.execute(
&mut pager,
parse_sql("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"CREATE TABLE orders (id INTEGER PRIMARY KEY, user_id INTEGER, amount REAL);",
)
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("INSERT INTO users (id, name) VALUES (1, 'Alice');").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("INSERT INTO users (id, name) VALUES (2, 'Bob');").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("INSERT INTO orders (id, user_id, amount) VALUES (10, 1, 150.0);")
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("INSERT INTO orders (id, user_id, amount) VALUES (20, 1, 50.0);")
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("INSERT INTO orders (id, user_id, amount) VALUES (30, 2, 200.0);")
.unwrap(),
)
.unwrap();
let ordered = executor
.query(
&mut pager,
parse_sql("SELECT id, amount FROM orders ORDER BY amount DESC;").unwrap(),
)
.unwrap();
assert_eq!(ordered.len(), 3);
assert_eq!(ordered[0].get::<f64>("amount").unwrap(), 200.0);
assert_eq!(ordered[1].get::<f64>("amount").unwrap(), 150.0);
assert_eq!(ordered[2].get::<f64>("amount").unwrap(), 50.0);
let agg = executor
.query(
&mut pager,
parse_sql("SELECT COUNT(*), SUM(amount), AVG(amount), MIN(amount), MAX(amount) FROM orders;").unwrap(),
)
.unwrap();
assert_eq!(agg.len(), 1);
assert_eq!(agg[0].get::<i64>("COUNT(*)").unwrap(), 3);
assert_eq!(agg[0].get::<f64>("SUM(amount)").unwrap(), 400.0);
assert_eq!(agg[0].get::<f64>("AVG(amount)").unwrap(), 400.0 / 3.0);
assert_eq!(agg[0].get::<f64>("MIN(amount)").unwrap(), 50.0);
assert_eq!(agg[0].get::<f64>("MAX(amount)").unwrap(), 200.0);
let joined = executor
.query(
&mut pager,
parse_sql("SELECT users.name, orders.amount FROM users INNER JOIN orders ON users.id = orders.user_id ORDER BY orders.amount ASC;").unwrap(),
)
.unwrap();
assert_eq!(joined.len(), 3);
assert_eq!(joined[0].get::<String>("users.name").unwrap(), "Alice");
assert_eq!(joined[0].get::<f64>("orders.amount").unwrap(), 50.0);
assert_eq!(joined[2].get::<String>("users.name").unwrap(), "Bob");
assert_eq!(joined[2].get::<f64>("orders.amount").unwrap(), 200.0);
}
#[test]
fn test_graph_match_cypher_query() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor
.execute(
&mut pager,
parse_sql(r#"GRAPH INSERT NODE 1 LABEL "Person" PROPERTIES "{\"name\":\"Alex\",\"role\":\"founder\"}";"#).unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(r#"GRAPH INSERT NODE 2 LABEL "Project" PROPERTIES "{\"title\":\"TapirusDB\"}";"#).unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(r#"GRAPH INSERT EDGE 1 2 LABEL "CREATOR_OF";"#).unwrap(),
)
.unwrap();
let query_sql = "GRAPH MATCH (a:Person)-[r:CREATOR_OF]->(b:Project) WHERE a.id = 1 RETURN a.name, b.title;";
let rows = executor
.query(&mut pager, parse_sql(query_sql).unwrap())
.expect("Execute graph match");
assert_eq!(rows.len(), 1);
assert_eq!(rows[0].get::<String>("a.name").unwrap(), "Alex");
assert_eq!(rows[0].get::<String>("b.title").unwrap(), "TapirusDB");
let match_sql = "MATCH (a)-[r]->(b) RETURN a.name, b.title;";
let rows2 = executor
.query(&mut pager, parse_sql(match_sql).unwrap())
.expect("Execute direct match");
assert_eq!(rows2.len(), 1);
assert_eq!(rows2[0].get::<String>("a.name").unwrap(), "Alex");
}
#[test]
fn test_executor_window_functions() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor
.execute(&mut pager, parse_sql("CREATE TABLE emp (id INTEGER PRIMARY KEY, name TEXT, dept TEXT, salary INTEGER);").unwrap())
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"INSERT INTO emp (id, name, dept, salary) VALUES (1, 'Alice', 'Eng', 9000);",
)
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"INSERT INTO emp (id, name, dept, salary) VALUES (2, 'Bob', 'Eng', 8000);",
)
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"INSERT INTO emp (id, name, dept, salary) VALUES (3, 'Charlie', 'Eng', 8000);",
)
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"INSERT INTO emp (id, name, dept, salary) VALUES (4, 'David', 'Sales', 7000);",
)
.unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql(
"INSERT INTO emp (id, name, dept, salary) VALUES (5, 'Eve', 'Sales', 6000);",
)
.unwrap(),
)
.unwrap();
let sql_rn = "SELECT id, name, dept, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn FROM emp ORDER BY id ASC;";
let rows_rn = executor
.query(&mut pager, parse_sql(sql_rn).unwrap())
.expect("Query ROW_NUMBER");
assert_eq!(rows_rn.len(), 5);
assert_eq!(rows_rn[0].get::<i64>("rn").unwrap(), 1);
assert_eq!(rows_rn[3].get::<i64>("rn").unwrap(), 1);
assert_eq!(rows_rn[4].get::<i64>("rn").unwrap(), 2);
let sql_dr = "SELECT id, salary, DENSE_RANK() OVER (ORDER BY salary DESC) AS drank FROM emp ORDER BY salary DESC;";
let rows_dr = executor
.query(&mut pager, parse_sql(sql_dr).unwrap())
.expect("Query DENSE_RANK");
assert_eq!(rows_dr[0].get::<i64>("drank").unwrap(), 1); assert_eq!(rows_dr[1].get::<i64>("drank").unwrap(), 2); assert_eq!(rows_dr[2].get::<i64>("drank").unwrap(), 2); assert_eq!(rows_dr[3].get::<i64>("drank").unwrap(), 3);
let sql_lag = "SELECT id, salary, LAG(salary, 1) OVER (ORDER BY id ASC) AS prev_sal, LEAD(salary, 1) OVER (ORDER BY id ASC) AS next_sal FROM emp ORDER BY id ASC;";
let rows_lag = executor
.query(&mut pager, parse_sql(sql_lag).unwrap())
.expect("Query LAG and LEAD");
assert_eq!(rows_lag[0].get_value("prev_sal"), Some(&Value::Null));
assert_eq!(rows_lag[0].get::<i64>("next_sal").unwrap(), 8000);
assert_eq!(rows_lag[1].get::<i64>("prev_sal").unwrap(), 9000);
let sql_sum = "SELECT id, dept, SUM(salary) OVER (PARTITION BY dept) AS total_dept FROM emp ORDER BY id ASC;";
let rows_sum = executor
.query(&mut pager, parse_sql(sql_sum).unwrap())
.expect("Query Window SUM");
assert_eq!(rows_sum[0].get::<i64>("total_dept").unwrap(), 25000); assert_eq!(rows_sum[3].get::<i64>("total_dept").unwrap(), 13000); }
#[test]
fn test_executor_graph_algorithms() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT NODE 1 LABEL \"Server\" PROPERTIES \"{}\";").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT NODE 2 LABEL \"Database\" PROPERTIES \"{}\";").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT NODE 3 LABEL \"Cache\" PROPERTIES \"{}\";").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT EDGE 1 2 LABEL \"CONNECTS\";").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT EDGE 2 3 LABEL \"CONNECTS\";").unwrap(),
)
.unwrap();
executor
.execute(
&mut pager,
parse_sql("GRAPH INSERT EDGE 3 1 LABEL \"CONNECTS\";").unwrap(),
)
.unwrap();
let pr_rows = executor
.query(&mut pager, parse_sql("GRAPH ALGORITHM PAGERANK;").unwrap())
.expect("PageRank query");
assert_eq!(pr_rows.len(), 3);
assert_eq!(pr_rows[0].columns(), &["node_id", "label", "pagerank"]);
let cc_rows = executor
.query(
&mut pager,
parse_sql("GRAPH ALGORITHM CONNECTED_COMPONENTS;").unwrap(),
)
.expect("WCC query");
assert_eq!(cc_rows.len(), 3);
assert_eq!(
cc_rows[0].get::<i64>("component_id").unwrap(),
cc_rows[1].get::<i64>("component_id").unwrap()
);
let bc_rows = executor
.query(
&mut pager,
parse_sql("GRAPH ALGORITHM BETWEENNESS;").unwrap(),
)
.expect("BC query");
assert_eq!(bc_rows.len(), 3);
let lv_rows = executor
.query(&mut pager, parse_sql("GRAPH ALGORITHM LOUVAIN;").unwrap())
.expect("Louvain query");
assert_eq!(lv_rows.len(), 3);
}
#[test]
fn test_executor_tap_decision_functions() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor
.execute(
&mut pager,
parse_sql(
"CREATE TABLE tickets (id INTEGER PRIMARY KEY, content TEXT, category TEXT);",
)
.unwrap(),
)
.unwrap();
executor.execute(&mut pager, parse_sql("INSERT INTO tickets VALUES (1, 'Urgent billing payment failed during checkout', 'billing');").unwrap()).unwrap();
executor.execute(&mut pager, parse_sql("INSERT INTO tickets VALUES (2, 'Cannot connect to wifi router hardware', 'hardware');").unwrap()).unwrap();
let rows = executor.query(&mut pager, parse_sql("SELECT id, TAP_CLASSIFY(content, 'billing, technical, sales') AS predicted FROM tickets;").unwrap()).unwrap();
assert_eq!(rows.len(), 2);
assert_eq!(rows[0].get::<String>("predicted").unwrap(), "billing");
let rows_v = executor.query(&mut pager, parse_sql("SELECT id, TAP_VERIFY(content, 'payment error occurred') AS is_payment_issue FROM tickets;").unwrap()).unwrap();
assert_eq!(rows_v.len(), 2);
assert_eq!(rows_v[0].get::<i64>("is_payment_issue").unwrap(), 1);
let rows_s = executor
.query(
&mut pager,
parse_sql(
"SELECT id, TAP_SCORE(content, 'urgent priority') AS urgency FROM tickets;",
)
.unwrap(),
)
.unwrap();
assert_eq!(rows_s.len(), 2);
assert!(rows_s[0].get::<f64>("urgency").unwrap() > 0.4);
let rows_r = executor.query(&mut pager, parse_sql("SELECT id, TAP_ROUTE(content, 'escalate_billing, triage, hardware_team') AS next_step FROM tickets;").unwrap()).unwrap();
assert_eq!(rows_r.len(), 2);
assert_eq!(
rows_r[0].get::<String>("next_step").unwrap(),
"escalate_billing"
);
let rows_where = executor.query(&mut pager, parse_sql("SELECT id, category FROM tickets WHERE TAP_VERIFY(content, 'wifi router hardware connection failure') = 1;").unwrap()).unwrap();
assert_eq!(rows_where.len(), 1);
assert_eq!(rows_where[0].get::<i64>("id").unwrap(), 2);
}
#[test]
fn test_executor_vector_cosine_and_timestamp() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut executor = SQLExecutor::new(&mut pager).expect("Init executor");
executor.execute(&mut pager, parse_sql("CREATE TABLE embeddings (doc_id INTEGER PRIMARY KEY, content TEXT, vector VECTOR(3), created_at TIMESTAMP);").unwrap()).unwrap();
executor.execute(&mut pager, parse_sql("INSERT INTO embeddings VALUES (1, 'Machine Learning', [1.0, 0.0, 0.0], '2026-10-09T08:00:00Z');").unwrap()).unwrap();
executor.execute(&mut pager, parse_sql("INSERT INTO embeddings VALUES (2, 'Culinary Arts', [0.0, 1.0, 0.0], '2026-10-09T08:01:00Z');").unwrap()).unwrap();
let rows = executor.query(&mut pager, parse_sql("SELECT doc_id, content, VECTOR_COSINE(vector, [0.9, 0.1, 0.0]) AS score FROM embeddings ORDER BY score DESC;").unwrap()).unwrap();
assert_eq!(rows.len(), 2);
assert_eq!(rows[0].get::<i64>("doc_id").unwrap(), 1);
let score_1 = rows[0].get::<f64>("score").unwrap();
let score_2 = rows[1].get::<f64>("score").unwrap();
assert!(score_1 > 0.9);
assert!(score_2 < 0.2);
let rows_l2 = executor.query(&mut pager, parse_sql("SELECT doc_id, VECTOR_L2(vector, [1.0, 0.0, 0.0]) AS dist FROM embeddings ORDER BY dist ASC;").unwrap()).unwrap();
assert_eq!(rows_l2[0].get::<i64>("doc_id").unwrap(), 1);
assert_eq!(rows_l2[0].get::<f64>("dist").unwrap(), 0.0);
}
}