use crate::btree::{engine, BTreeStorage};
use crate::error::{Error, Result};
use crate::pager::{PageId, Pager};
use crate::traits::Value;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum DataType {
Integer,
Real,
Text,
Blob,
Vector(usize),
}
impl DataType {
pub fn coerce_value(&self, val: Value) -> Result<Value> {
match self {
DataType::Integer => match val {
Value::Integer(i) => Ok(Value::Integer(i)),
Value::Real(r) => {
if r.fract() == 0.0 && r >= (i64::MIN as f64) && r <= (i64::MAX as f64) {
Ok(Value::Integer(r as i64))
} else {
Err(Error::ConstraintViolation(format!(
"Cannot store floating-point {r} in INTEGER column without truncation"
)))
}
}
Value::Text(ref s) => {
if let Ok(i) = s.parse::<i64>() {
Ok(Value::Integer(i))
} else {
Err(Error::ConstraintViolation(format!(
"Cannot convert text '{s}' to INTEGER"
)))
}
}
Value::Null => Ok(Value::Null),
other => Err(Error::ConstraintViolation(format!(
"Invalid value {other:?} for INTEGER column"
))),
},
DataType::Real => match val {
Value::Real(r) => Ok(Value::Real(r)),
Value::Integer(i) => Ok(Value::Real(i as f64)),
Value::Text(ref s) => {
if let Ok(r) = s.parse::<f64>() {
Ok(Value::Real(r))
} else {
Err(Error::ConstraintViolation(format!(
"Cannot convert text '{s}' to REAL"
)))
}
}
Value::Null => Ok(Value::Null),
other => Err(Error::ConstraintViolation(format!(
"Invalid value {other:?} for REAL column"
))),
},
DataType::Text => match val {
Value::Text(s) => Ok(Value::Text(s)),
Value::Integer(i) => Ok(Value::Text(i.to_string())),
Value::Real(r) => Ok(Value::Text(r.to_string())),
Value::Null => Ok(Value::Null),
other => Err(Error::ConstraintViolation(format!(
"Invalid value {other:?} for TEXT column"
))),
},
DataType::Blob => match val {
Value::Blob(b) => Ok(Value::Blob(b)),
Value::Null => Ok(Value::Null),
other => Err(Error::ConstraintViolation(format!(
"Invalid value {other:?} for BLOB column"
))),
},
DataType::Vector(expected_dim) => match val {
Value::Vector(v) => {
if v.len() != *expected_dim {
Err(Error::DimensionMismatch(*expected_dim, v.len()))
} else {
Ok(Value::Vector(v))
}
}
Value::Text(ref s) => {
let trimmed = s.trim();
if trimmed.starts_with('[') && trimmed.ends_with(']') {
let inner = &trimmed[1..trimmed.len() - 1];
let parsed: std::result::Result<Vec<f32>, _> = inner
.split(',')
.map(|part| part.trim().parse::<f32>())
.collect();
if let Ok(vec) = parsed {
if vec.len() != *expected_dim {
return Err(Error::DimensionMismatch(*expected_dim, vec.len()));
}
return Ok(Value::Vector(vec));
}
}
Err(Error::ConstraintViolation(format!(
"Expected VECTOR({expected_dim}), got Text(\"{s}\")"
)))
}
Value::Null => Ok(Value::Null),
other => Err(Error::ConstraintViolation(format!(
"Expected VECTOR({expected_dim}), got {other:?}"
))),
},
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ColumnDef {
pub name: String,
pub data_type: DataType,
pub primary_key: bool,
pub not_null: bool,
}
impl ColumnDef {
pub fn new(name: impl Into<String>, data_type: DataType) -> Self {
Self {
name: name.into(),
data_type,
primary_key: false,
not_null: false,
}
}
pub fn primary_key(mut self) -> Self {
self.primary_key = true;
self
}
pub fn not_null(mut self) -> Self {
self.not_null = true;
self
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct TableDef {
pub name: String,
pub root_page: PageId,
pub columns: Vec<ColumnDef>,
pub next_row_id: u64,
}
impl TableDef {
pub fn new(name: String, root_page: PageId, columns: Vec<ColumnDef>) -> Self {
Self {
name,
root_page,
columns,
next_row_id: 1,
}
}
pub fn column_index(&self, col_name: &str) -> Option<usize> {
self.columns
.iter()
.position(|c| c.name.eq_ignore_ascii_case(col_name))
}
pub fn column_names(&self) -> Vec<String> {
self.columns.iter().map(|c| c.name.clone()).collect()
}
pub fn primary_key_index(&self) -> Option<usize> {
self.columns.iter().position(|c| c.primary_key)
}
pub fn vector_column(&self) -> Option<(usize, usize)> {
for (idx, col) in self.columns.iter().enumerate() {
if let DataType::Vector(dims) = col.data_type {
return Some((idx, dims));
}
}
None
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ViewDef {
pub name: String,
pub query_sql: String,
}
impl ViewDef {
pub fn new(name: impl Into<String>, query_sql: impl Into<String>) -> Self {
Self {
name: name.into(),
query_sql: query_sql.into(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IndexDef {
pub name: String,
pub table: String,
pub column: String,
pub root_page: PageId,
pub unique: bool,
}
impl IndexDef {
pub fn new(
name: impl Into<String>,
table: impl Into<String>,
column: impl Into<String>,
root_page: PageId,
) -> Self {
Self {
name: name.into(),
table: table.into(),
column: column.into(),
root_page,
unique: false,
}
}
}
#[derive(Debug, Default, Clone)]
pub struct Catalog {
tables: HashMap<String, TableDef>,
views: HashMap<String, ViewDef>,
indexes: HashMap<String, IndexDef>,
stats: HashMap<String, crate::sql::planner::TableStats>,
next_table_id: u64,
}
impl Catalog {
pub fn new() -> Self {
Self {
tables: HashMap::new(),
views: HashMap::new(),
indexes: HashMap::new(),
stats: HashMap::new(),
next_table_id: 1,
}
}
pub fn load(pager: &mut Pager) -> Result<Self> {
let mut catalog = Self::new();
let page1_buf = pager.read_page(1)?;
let header = engine::read_page_header(&page1_buf, 1);
if header.is_err() {
let mut page1_init = page1_buf.clone();
engine::init_leaf_page(&mut page1_init, 1);
pager.write_page(1, &page1_init)?;
return Ok(catalog);
}
let btree = BTreeStorage::new();
let cells = btree.scan(pager, 1)?;
for cell in cells {
if let Ok(table_def) = serde_json::from_slice::<TableDef>(&cell.payload) {
if cell.row_id >= catalog.next_table_id {
catalog.next_table_id = cell.row_id + 1;
}
catalog.tables.insert(table_def.name.to_lowercase(), table_def);
} else if let Ok(view_def) = serde_json::from_slice::<ViewDef>(&cell.payload) {
if cell.row_id >= catalog.next_table_id {
catalog.next_table_id = cell.row_id + 1;
}
catalog.views.insert(view_def.name.to_lowercase(), view_def);
} else if let Ok(index_def) = serde_json::from_slice::<IndexDef>(&cell.payload) {
if cell.row_id >= catalog.next_table_id {
catalog.next_table_id = cell.row_id + 1;
}
catalog.indexes.insert(index_def.name.to_lowercase(), index_def);
}
}
Ok(catalog)
}
pub fn table_exists(&self, name: &str) -> bool {
self.tables.contains_key(&name.to_lowercase())
}
pub fn tables(&self) -> Vec<TableDef> {
self.tables.values().cloned().collect()
}
pub fn get_table(&self, name: &str) -> Option<&TableDef> {
self.tables.get(&name.to_lowercase())
}
pub fn get_table_mut(&mut self, name: &str) -> Option<&mut TableDef> {
self.tables.get_mut(&name.to_lowercase())
}
pub fn create_table(&mut self, pager: &mut Pager, table_def: TableDef) -> Result<()> {
let name_lower = table_def.name.to_lowercase();
if self.tables.contains_key(&name_lower) {
return Err(Error::TableExists(table_def.name));
}
let table_id = self.next_table_id;
self.next_table_id += 1;
let payload = serde_json::to_vec(&table_def)
.map_err(|e| Error::Corrupted(format!("Failed to serialize table def: {e}")))?;
let mut btree = BTreeStorage::new();
btree.insert(pager, 1, table_id, &payload)?;
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
self.tables.insert(name_lower, table_def);
Ok(())
}
pub fn add_column(&mut self, pager: &mut Pager, table_name: &str, col_def: ColumnDef) -> Result<()> {
let name_lower = table_name.to_lowercase();
let table_def = self
.tables
.get_mut(&name_lower)
.ok_or_else(|| Error::TableNotFound(table_name.to_string()))?;
if table_def.column_index(&col_def.name).is_some() {
return Err(Error::SqlSyntax(format!(
"Column '{}' already exists in table '{}'",
col_def.name, table_name
)));
}
table_def.columns.push(col_def);
let updated_def = table_def.clone();
let mut btree = BTreeStorage::new();
let cells = btree.scan(pager, 1)?;
for cell in cells {
if let Ok(td) = serde_json::from_slice::<TableDef>(&cell.payload) {
if td.name.eq_ignore_ascii_case(table_name) {
let payload = serde_json::to_vec(&updated_def)
.map_err(|e| Error::Corrupted(format!("Failed to serialize updated table def: {e}")))?;
btree.delete(pager, 1, cell.row_id)?;
btree.insert(pager, 1, cell.row_id, &payload)?;
break;
}
}
}
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
Ok(())
}
pub fn drop_table(&mut self, pager: &mut Pager, table_name: &str) -> Result<bool> {
let name_lower = table_name.to_lowercase();
if let Some(table_def) = self.tables.remove(&name_lower) {
let mut btree = BTreeStorage::new();
let cells = btree.scan(pager, 1)?;
for cell in cells {
if let Ok(td) = serde_json::from_slice::<TableDef>(&cell.payload) {
if td.name.eq_ignore_ascii_case(&table_def.name) {
let _ = btree.delete(pager, 1, cell.row_id);
break;
}
}
}
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
Ok(true)
} else {
Ok(false)
}
}
pub fn create_view(&mut self, pager: &mut Pager, view_def: ViewDef) -> Result<()> {
let name_lower = view_def.name.to_lowercase();
if self.tables.contains_key(&name_lower) {
return Err(Error::TableExists(format!("Table with name '{}' already exists", view_def.name)));
}
if self.views.contains_key(&name_lower) {
return Err(Error::TableExists(format!("View '{}' already exists", view_def.name)));
}
let entry_id = self.next_table_id;
self.next_table_id += 1;
let payload = serde_json::to_vec(&view_def)
.map_err(|e| Error::Corrupted(format!("Failed to serialize view def: {e}")))?;
let mut btree = BTreeStorage::new();
btree.insert(pager, 1, entry_id, &payload)?;
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
self.views.insert(name_lower, view_def);
Ok(())
}
pub fn drop_view(&mut self, pager: &mut Pager, view_name: &str) -> Result<bool> {
let name_lower = view_name.to_lowercase();
if self.views.remove(&name_lower).is_some() {
let mut btree = BTreeStorage::new();
let cells = btree.scan(pager, 1)?;
for cell in cells {
if let Ok(vd) = serde_json::from_slice::<ViewDef>(&cell.payload) {
if vd.name.eq_ignore_ascii_case(view_name) {
let _ = btree.delete(pager, 1, cell.row_id);
break;
}
}
}
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
Ok(true)
} else {
Ok(false)
}
}
pub fn view_exists(&self, name: &str) -> bool {
self.views.contains_key(&name.to_lowercase())
}
pub fn get_view(&self, name: &str) -> Option<&ViewDef> {
self.views.get(&name.to_lowercase())
}
pub fn views(&self) -> Vec<ViewDef> {
self.views.values().cloned().collect()
}
pub fn index_exists(&self, name: &str) -> bool {
self.indexes.contains_key(&name.to_lowercase())
}
pub fn get_index(&self, name: &str) -> Option<&IndexDef> {
self.indexes.get(&name.to_lowercase())
}
pub fn find_index_for_column(&self, table: &str, column: &str) -> Option<&IndexDef> {
self.indexes.values().find(|idx| {
idx.table.eq_ignore_ascii_case(table) && idx.column.eq_ignore_ascii_case(column)
})
}
pub fn indexes(&self) -> Vec<IndexDef> {
self.indexes.values().cloned().collect()
}
pub fn get_table_stats(&self, table: &str) -> Option<&crate::sql::planner::TableStats> {
self.stats.get(&table.to_lowercase())
}
pub fn set_table_stats(&mut self, table: &str, stats: crate::sql::planner::TableStats) {
self.stats.insert(table.to_lowercase(), stats);
}
pub fn create_index(&mut self, pager: &mut Pager, index_def: IndexDef) -> Result<()> {
let name_lower = index_def.name.to_lowercase();
if self.indexes.contains_key(&name_lower) {
return Err(Error::TableExists(format!("Index '{}' already exists", index_def.name)));
}
let entry_id = self.next_table_id;
self.next_table_id += 1;
let payload = serde_json::to_vec(&index_def)
.map_err(|e| Error::Corrupted(format!("Failed to serialize index def: {e}")))?;
let mut btree = BTreeStorage::new();
btree.insert(pager, 1, entry_id, &payload)?;
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
self.indexes.insert(name_lower, index_def);
Ok(())
}
pub fn drop_index(&mut self, pager: &mut Pager, index_name: &str) -> Result<bool> {
let name_lower = index_name.to_lowercase();
if self.indexes.remove(&name_lower).is_some() {
let mut btree = BTreeStorage::new();
let cells = btree.scan(pager, 1)?;
for cell in cells {
if let Ok(id) = serde_json::from_slice::<IndexDef>(&cell.payload) {
if id.name.eq_ignore_ascii_case(index_name) {
let _ = btree.delete(pager, 1, cell.row_id);
break;
}
}
}
pager.header_mut().schema_cookie += 1;
let header_bytes = pager.header().to_bytes();
let mut page1_buf = pager.read_page(1)?;
page1_buf[..crate::pager::DATABASE_HEADER_SIZE].copy_from_slice(&header_bytes);
pager.write_page(1, &page1_buf)?;
Ok(true)
} else {
Ok(false)
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_catalog_create_and_load() {
let mut pager = Pager::open_in_memory(4096, 128).expect("Pager open");
let mut catalog = Catalog::load(&mut pager).expect("Load catalog");
let cols = vec![
ColumnDef {
name: "id".to_string(),
data_type: DataType::Integer,
primary_key: true,
not_null: true,
},
ColumnDef {
name: "title".to_string(),
data_type: DataType::Text,
primary_key: false,
not_null: false,
},
ColumnDef {
name: "embedding".to_string(),
data_type: DataType::Vector(128),
primary_key: false,
not_null: false,
},
];
let table_root = pager.allocate_page().expect("Alloc table root");
let mut root_buf = vec![0u8; 4096];
engine::init_leaf_page(&mut root_buf, table_root);
pager.write_page(table_root, &root_buf).expect("Init table root");
let table_def = TableDef::new("documents".to_string(), table_root, cols);
catalog.create_table(&mut pager, table_def.clone()).expect("Create table");
assert!(catalog.table_exists("DOCUMENTS"));
let retrieved = catalog.get_table("documents").unwrap();
assert_eq!(retrieved.root_page, table_root);
assert_eq!(retrieved.columns.len(), 3);
assert_eq!(retrieved.vector_column(), Some((2, 128)));
let reloaded = Catalog::load(&mut pager).expect("Reload catalog");
assert!(reloaded.table_exists("documents"));
let t = reloaded.get_table("documents").unwrap();
assert_eq!(t.name, "documents");
assert_eq!(t.root_page, table_root);
}
}