use std::cell::{Cell, RefCell};
use std::collections::{BTreeMap, BTreeSet};
use std::fs::{self, File, OpenOptions};
use std::io::{Read, Seek, SeekFrom, Write};
use std::path::{Path, PathBuf};
#[cfg(feature = "enterprise")]
use std::sync::Arc;
use std::time::Instant;
mod aggregate;
mod explain;
#[cfg(not(target_arch = "wasm32"))]
use fs2::FileExt;
use serde::{Deserialize, Serialize};
use crate::core::errors::{PvError, Result};
use crate::core::types::{
pack_addr, unpack_addr, FileHeader, PageId, PageType, RecordAddr, RecordEnvelope, TxId,
FILE_HEADER_SIZE, FORMAT_VERSION, FORMAT_VERSION_BASE, FORMAT_VERSION_COLUMNAR,
FORMAT_VERSION_CONSTRAINTS, FORMAT_VERSION_INDEX, FORMAT_VERSION_SCHEMA, PAGE_HEADER_SIZE,
PAGE_SIZE,
};
use crate::core::value::{Row, Value, DECIMAL_DEN};
use crate::engine::compliance::{ComplianceMonitor, RuntimeMetrics};
use crate::engine::mvcc::{Snapshot, TxManager};
use crate::engine::query::{
agg_label, parse, AggFunc, Aggregate, ColumnDefinition, CompareOp, HavingPred, HavingTerm,
InsertValue, JoinClause, OrderBy, Predicate, Projection, ScalarExpr, ScalarFunc, SelectExpr,
SelectItem, Statement, TableRef,
};
use crate::engine::wasm::WasmRuntime;
use crate::storage::cache::{PageCache, DEFAULT_CACHE_PAGES};
use crate::storage::cas::{verify_blob_hash_hex, CasStore};
use crate::storage::index::SecondaryIndex;
use crate::storage::page::{ColdPage, RowPage, RowPageRef, SLOT_SIZE};
use crate::storage::record::{decode_record, encode_record};
use crate::storage::vle::{
bake_monolith_bytes_with_index, verify_page_checksum, Backend, DevStore, MemStore, Monolith,
RangeReader, RemoteStore,
};
use crate::CancellationToken;
pub const MANIFEST_FILE: &str = "pv_manifest.json";
pub const TRANSACTION_MARKER_FILE: &str = ".pv_transaction_active";
pub const TRANSACTION_BACKUP_DIR: &str = ".pv_transaction_backup";
pub const TRANSACTION_LOCK_FILE: &str = ".pv_transaction.lock";
const MAX_STREAM_TAIL_BYTES: usize = 64 * 1024 * 1024;
const MAX_RECORD: usize = PAGE_SIZE - PAGE_HEADER_SIZE - SLOT_SIZE;
struct Table {
columns: Vec<String>,
unique_columns: BTreeSet<String>,
not_null_columns: BTreeSet<String>,
defaults: BTreeMap<String, Value>,
checks: Vec<Predicate>,
first_page: Option<PageId>,
tail_id: Option<PageId>,
tail: Option<RowPage>,
row_versions: u64,
cold_pages: u64,
compaction_cursor: Option<PageId>,
page_ids: RefCell<Option<BTreeSet<PageId>>>,
indexes: BTreeMap<String, SecondaryIndex>,
}
#[derive(Serialize, Deserialize, Default)]
struct Manifest {
#[serde(default)]
format_version: u16,
clock: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
commit_sequence: Option<u64>,
page_count: u64,
tables: Vec<TableMeta>,
cas_hashes: Vec<String>,
#[serde(default)]
cas_dir: Vec<(u64, u64)>,
#[serde(default, skip_serializing_if = "Option::is_none")]
index_region: Option<(u64, u64)>,
}
fn check_manifest_version(m: &Manifest) -> Result<()> {
if m.format_version == 0 || m.format_version > FORMAT_VERSION {
return Err(PvError::Corruption(format!(
"unsupported workspace format version {}; this build reads up to {FORMAT_VERSION}",
m.format_version
)));
}
let required = required_manifest_version(m);
if m.format_version < required {
return Err(PvError::Corruption(format!(
"workspace format version {} understates persisted features that require version {required}",
m.format_version
)));
}
Ok(())
}
fn check_header_manifest_version(header_version: u16, manifest: &Manifest) -> Result<()> {
if header_version != manifest.format_version {
return Err(PvError::Corruption(format!(
"file header format version {header_version} does not match manifest version {}",
manifest.format_version
)));
}
Ok(())
}
fn required_manifest_version(manifest: &Manifest) -> u16 {
let mut required = FORMAT_VERSION_BASE;
if manifest.commit_sequence.is_some() {
required = crate::FORMAT_VERSION_COMMIT_ANCHOR;
}
if manifest.index_region.is_some()
|| manifest
.tables
.iter()
.any(|table| !table.binary_indexes.is_empty())
{
required = required.max(FORMAT_VERSION_INDEX);
}
if manifest
.tables
.iter()
.any(|table| !table.unique_columns.is_empty() || !table.not_null_columns.is_empty())
{
required = required.max(FORMAT_VERSION_CONSTRAINTS);
}
if manifest
.tables
.iter()
.any(|table| !table.defaults.is_empty() || !table.checks.is_empty())
{
required = required.max(FORMAT_VERSION_SCHEMA);
}
if manifest
.tables
.iter()
.any(|table| table.cold_pages > 0 || table.compaction_cursor.is_some())
{
required = required.max(FORMAT_VERSION_COLUMNAR);
}
required
}
#[derive(Serialize, Deserialize)]
struct TableMeta {
name: String,
columns: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
unique_columns: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
not_null_columns: Vec<String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
defaults: BTreeMap<String, Value>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
checks: Vec<Predicate>,
first_page: Option<u64>,
tail_id: Option<u64>,
row_versions: u64,
#[serde(default, skip_serializing_if = "is_zero")]
cold_pages: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
compaction_cursor: Option<u64>,
#[serde(default)]
indexed_columns: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
indexes: Vec<PersistedIndex>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
binary_indexes: Vec<BinIndexDesc>,
}
#[derive(Serialize, Deserialize)]
struct PersistedIndex {
column: String,
pairs: Vec<(Value, Vec<RecordAddr>)>,
}
#[derive(Serialize, Deserialize, Clone)]
struct BinIndexDesc {
column: String,
offset: u64,
len: u64,
}
fn is_zero(value: &u64) -> bool {
*value == 0
}
#[derive(Debug, Clone, PartialEq)]
pub enum QueryResult {
Rows {
columns: Vec<String>,
rows: Vec<Row>,
},
Mutated(usize),
Done,
}
impl QueryResult {
pub fn rows(&self) -> Option<&[Row]> {
match self {
QueryResult::Rows { rows, .. } => Some(rows),
_ => None,
}
}
pub fn columns(&self) -> Option<&[String]> {
match self {
QueryResult::Rows { columns, .. } => Some(columns),
_ => None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct DatabaseStats {
pub format_version: u16,
pub current_transaction: u64,
pub storage_mode: String,
pub writable: bool,
pub page_size: usize,
pub allocated_pages: u64,
pub allocated_page_bytes: u64,
pub orphaned_pages: u64,
pub buffer_pool: BufferPoolStats,
pub cas: CasStats,
pub tables: Vec<TableStats>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct BufferPoolStats {
pub capacity_pages: usize,
pub resident_pages: usize,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct CasStats {
pub blobs: usize,
pub stored_bytes: u64,
}
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct TableStats {
pub name: String,
pub columns: Vec<String>,
pub live_rows: u64,
pub row_versions: u64,
pub pages: u64,
pub used_page_bytes: u64,
pub free_page_bytes: u64,
pub compression: CompressionStats,
pub indexes: Vec<IndexStats>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct CompressionStats {
pub codec: String,
pub compressed_pages: u64,
pub saved_bytes: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct CompactionReport {
pub examined_pages: u64,
pub compacted_pages: u64,
pub skipped_pages: u64,
pub input_bytes: u64,
pub encoded_bytes: u64,
pub saved_bytes: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
pub struct IndexStats {
pub column: String,
pub entries: usize,
pub distinct_keys: usize,
pub encoded_bytes: usize,
}
#[derive(Debug, Clone, Copy)]
pub struct QueryLimits {
pub max_rows_scanned: usize,
pub max_materialized_bytes: usize,
pub max_result_rows: usize,
pub deadline: Option<Instant>,
}
#[derive(Debug, Clone)]
pub struct PreparedStatement {
sql: String,
parameter_count: usize,
}
impl PreparedStatement {
pub fn parameter_count(&self) -> usize {
self.parameter_count
}
pub fn execute(&self, database: &mut Database, params: &[Value]) -> Result<QueryResult> {
if params.len() != self.parameter_count {
return Err(PvError::Schema(format!(
"prepared statement expects {} parameters, got {}",
self.parameter_count,
params.len()
)));
}
database.query_with(&self.sql, params)
}
}
impl QueryLimits {
pub const fn new(
max_rows_scanned: usize,
max_materialized_bytes: usize,
max_result_rows: usize,
deadline: Option<Instant>,
) -> Self {
Self {
max_rows_scanned,
max_materialized_bytes,
max_result_rows,
deadline,
}
}
}
struct QueryBudget {
limits: QueryLimits,
rows_scanned: usize,
materialized_bytes: usize,
cancellation: Option<CancellationToken>,
}
impl QueryBudget {
fn new_cancellable(limits: QueryLimits, cancellation: Option<CancellationToken>) -> Self {
Self {
limits,
rows_scanned: 0,
materialized_bytes: 0,
cancellation,
}
}
fn checkpoint(&self) -> Result<()> {
if let Some(cancellation) = &self.cancellation {
cancellation.check()?;
}
if self
.limits
.deadline
.is_some_and(|deadline| Instant::now() >= deadline)
{
return Err(PvError::ResourceLimit("deadline expired".into()));
}
Ok(())
}
fn scan_row(&mut self) -> Result<()> {
self.checkpoint()?;
self.rows_scanned = self.rows_scanned.saturating_add(1);
if self.rows_scanned > self.limits.max_rows_scanned {
return Err(PvError::ResourceLimit(format!(
"scanned more than {} rows",
self.limits.max_rows_scanned
)));
}
Ok(())
}
fn reserve_index_candidates(&mut self, count: usize) -> Result<()> {
self.checkpoint()?;
let remaining = self
.limits
.max_rows_scanned
.saturating_sub(self.rows_scanned);
if count > remaining {
return Err(PvError::ResourceLimit(format!(
"index produced more than {remaining} remaining row candidates"
)));
}
let bytes = count.saturating_mul(std::mem::size_of::<RecordAddr>());
self.materialized_bytes = self.materialized_bytes.saturating_add(bytes);
if self.materialized_bytes > self.limits.max_materialized_bytes {
return Err(PvError::ResourceLimit(format!(
"index candidates materialized more than {} bytes",
self.limits.max_materialized_bytes
)));
}
Ok(())
}
fn materialize(&mut self, row: &Row) -> Result<()> {
let bytes = row.iter().fold(std::mem::size_of::<Row>(), |total, value| {
total.saturating_add(match value {
Value::Null | Value::Int(_) | Value::Decimal(_) => std::mem::size_of::<Value>(),
Value::Text(value) => std::mem::size_of::<Value>().saturating_add(value.len()),
Value::Blob(value) => std::mem::size_of::<Value>().saturating_add(value.len()),
})
});
self.materialized_bytes = self.materialized_bytes.saturating_add(bytes);
if self.materialized_bytes > self.limits.max_materialized_bytes {
return Err(PvError::ResourceLimit(format!(
"materialized more than {} bytes",
self.limits.max_materialized_bytes
)));
}
Ok(())
}
fn materialize_value(&mut self, value: &Value, context: &str) -> Result<()> {
self.checkpoint()?;
let bytes = std::mem::size_of::<Value>().saturating_add(match value {
Value::Text(value) => value.len(),
Value::Blob(value) => value.len(),
Value::Null | Value::Int(_) | Value::Decimal(_) => 0,
});
self.materialized_bytes = self.materialized_bytes.saturating_add(bytes);
if self.materialized_bytes > self.limits.max_materialized_bytes {
return Err(PvError::ResourceLimit(format!(
"{context} materialized more than {} bytes",
self.limits.max_materialized_bytes
)));
}
Ok(())
}
fn check_result(&self, result: &QueryResult) -> Result<()> {
if let QueryResult::Rows { rows, .. } = result {
self.checkpoint()?;
if rows.len() > self.limits.max_result_rows {
return Err(PvError::ResourceLimit(format!(
"result has more than {} rows; add or lower LIMIT",
self.limits.max_result_rows
)));
}
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Durability {
#[default]
Fast,
Sync,
}
enum TransactionRollback {
Memory(Vec<u8>),
Filesystem(PathBuf),
Journal(PathBuf),
}
struct ActiveTransaction {
rollback: TransactionRollback,
previous_autocommit: bool,
previous_durability: Durability,
_filesystem_lock: Option<TransactionLock>,
}
pub struct Database {
cache: RefCell<PageCache>,
cas: CasStore,
txm: TxManager,
tables: BTreeMap<String, Table>,
compliance: ComplianceMonitor,
root: Option<PathBuf>,
autocommit: bool,
durability: Durability,
format_version_floor: u16,
manifest_file: RefCell<Option<File>>,
active_transaction: Option<ActiveTransaction>,
commit_log: Option<crate::CommitLogOptions>,
synced: Cell<bool>,
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime,
}
impl Database {
#[cfg(not(target_arch = "wasm32"))]
pub(crate) fn is_memory_backed(&self) -> bool {
matches!(self.cache.borrow().backend(), Backend::Mem(_))
}
pub fn enable_commit_log(&mut self, options: crate::CommitLogOptions) -> Result<()> {
if self.in_transaction() {
return Err(PvError::Transaction(
"cannot configure log during a transaction".into(),
));
}
if self.root.is_none() {
return Err(PvError::Transaction(
"commit log requires a filesystem workspace".into(),
));
}
self.commit_log = Some(options.validate()?);
self.synced.set(false);
self.format_version_floor = self
.format_version_floor
.max(crate::FORMAT_VERSION_COMMIT_ANCHOR);
Ok(())
}
pub fn changes_since(&self, after: u64, limit: usize) -> Result<Vec<crate::ChangeCommit>> {
let root = self.root.as_ref().ok_or_else(|| {
PvError::Transaction("change stream requires a filesystem workspace".into())
})?;
crate::journal::changes(root, after, limit)
}
pub fn commit_log_status(&self) -> Result<crate::CommitLogStatus> {
let options = self.commit_log.ok_or_else(|| {
PvError::Transaction("commit log is not enabled; call enable_commit_log first".into())
})?;
let root = self.root.as_ref().ok_or_else(|| {
PvError::Transaction("commit log requires a filesystem workspace".into())
})?;
crate::journal::status(root, options)
}
pub fn export_checkpoint(
&mut self,
destination: impl AsRef<Path>,
) -> Result<crate::SnapshotCheckpoint> {
if self.in_transaction() {
return Err(PvError::Transaction(
"cannot export an uncommitted checkpoint".into(),
));
}
let root = self.root.clone().ok_or_else(|| {
PvError::Transaction("checkpoint requires a filesystem workspace".into())
})?;
let _lock = acquire_transaction_lock(&root)?;
let sequence = crate::journal::head(&root)?;
let verification_hash = self.verification_hash()?;
let destination = destination.as_ref();
let parent = destination
.parent()
.filter(|p| !p.as_os_str().is_empty())
.unwrap_or(Path::new("."));
if fs::canonicalize(parent)?.starts_with(fs::canonicalize(&root)?) {
return Err(PvError::Transaction(
"checkpoint destination must be outside the live workspace".into(),
));
}
let mut temporary = tempfile::NamedTempFile::new_in(parent)?;
self.bake_to_writer(temporary.as_file_mut())?;
temporary.as_file().sync_all()?;
if Database::open_prod(temporary.path())?.verification_hash()? != verification_hash {
return Err(PvError::Corruption(
"checkpoint verification mismatch".into(),
));
}
temporary
.persist_noclobber(destination)
.map_err(|error| PvError::Io(error.error))?;
sync_directory(parent)?;
Ok(crate::SnapshotCheckpoint {
sequence,
transaction: self.current_tx(),
verification_hash,
})
}
pub fn prune_changes(&mut self, through: u64) -> Result<()> {
if self.in_transaction() {
return Err(PvError::Transaction(
"cannot prune during a transaction".into(),
));
}
let root = self.root.as_ref().ok_or_else(|| {
PvError::Transaction("change stream requires a filesystem workspace".into())
})?;
let _lock = acquire_transaction_lock(root)?;
crate::journal::prune(root, through)
}
pub fn open_dev(path: impl AsRef<Path>) -> Result<Self> {
let root = path.as_ref().to_path_buf();
fs::create_dir_all(&root)?;
let recovery_lock = acquire_transaction_lock(&root)?;
recover_workspace_transaction(&root)?;
crate::journal::recover(&root)?;
drop(recovery_lock);
let commit_log = root
.join(crate::COMMIT_LOG_DIR)
.exists()
.then(crate::CommitLogOptions::default);
let manifest_path = root.join(MANIFEST_FILE);
if manifest_path.exists() {
let manifest: Manifest = serde_json::from_slice(&fs::read(&manifest_path)?)?;
check_manifest_version(&manifest)?;
let commit_log = commit_log.or_else(|| {
manifest
.commit_sequence
.map(|_| crate::CommitLogOptions::default())
});
let dev = DevStore::open(&root, manifest.page_count)?;
let mut cache = PageCache::new(Backend::Dev(dev), DEFAULT_CACHE_PAGES);
let cas = CasStore::load_dev(&root, &manifest.cas_hashes)?;
let tables = build_tables(&mut cache, &cas, &manifest, true, &[])?;
Ok(Self {
cache: RefCell::new(cache),
cas,
txm: TxManager::with_clock(manifest.clock),
tables,
compliance: ComplianceMonitor::new(),
root: Some(root),
autocommit: true,
durability: Durability::Fast,
format_version_floor: if commit_log.is_some() {
manifest
.format_version
.max(crate::FORMAT_VERSION_COMMIT_ANCHOR)
} else {
manifest.format_version
},
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
})
} else {
let dev = DevStore::create(&root)?;
Ok(Self {
cache: RefCell::new(PageCache::new(Backend::Dev(dev), DEFAULT_CACHE_PAGES)),
cas: CasStore::new_dev(&root),
txm: TxManager::new(),
tables: BTreeMap::new(),
compliance: ComplianceMonitor::new(),
root: Some(root),
autocommit: true,
durability: Durability::Fast,
format_version_floor: FORMAT_VERSION_BASE,
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log: None,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
})
}
}
pub fn open_prod(path: impl AsRef<Path>) -> Result<Self> {
let mono = Monolith::open(path)?;
let manifest: Manifest = serde_json::from_slice(mono.manifest_bytes())?;
check_manifest_version(&manifest)?;
check_header_manifest_version(mono.format_version(), &manifest)?;
let cas = CasStore::from_mapped(
mono.mmap(),
mono.cas_offset(),
cas_pool_end(&manifest, mono.cas_offset(), mono.manifest_offset())?,
&manifest.cas_dir,
&manifest.cas_hashes,
)?;
let map = mono.mmap();
let region = slice_index_region(
&map,
&manifest,
mono.cas_offset() as u64,
mono.manifest_offset(),
)?;
let mut cache = PageCache::new(Backend::Prod(mono), DEFAULT_CACHE_PAGES);
let tables = build_tables(&mut cache, &cas, &manifest, false, region)?;
Ok(Self {
cache: RefCell::new(cache),
cas,
txm: TxManager::with_clock(manifest.clock),
tables,
compliance: ComplianceMonitor::new(),
root: None,
autocommit: false,
durability: Durability::Fast,
format_version_floor: manifest.format_version,
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log: None,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
})
}
pub fn open_streamed(reader: Box<dyn RangeReader>, total_size: u64) -> Result<Self> {
let header_bytes = reader.read_at(0, FILE_HEADER_SIZE)?;
if header_bytes.len() != FILE_HEADER_SIZE {
return Err(PvError::Corruption(
"streamed: header range has the wrong length".into(),
));
}
let header = FileHeader::decode(&header_bytes)?; let total_size = usize::try_from(total_size).map_err(|_| {
PvError::Corruption("streamed: image is too large for this platform".into())
})?;
let cas_offset = usize::try_from(header.cas_offset)
.map_err(|_| PvError::Corruption("streamed: CAS offset is too large".into()))?;
let manifest_offset = usize::try_from(header.manifest_offset)
.map_err(|_| PvError::Corruption("streamed: manifest offset is too large".into()))?;
if cas_offset < FILE_HEADER_SIZE
|| manifest_offset < cas_offset
|| manifest_offset > total_size
|| (cas_offset - FILE_HEADER_SIZE) % PAGE_SIZE != 0
{
return Err(PvError::Corruption("streamed: inconsistent offsets".into()));
}
let page_count = ((cas_offset - FILE_HEADER_SIZE) / PAGE_SIZE) as u64;
let tail_len = total_size
.checked_sub(cas_offset)
.ok_or_else(|| PvError::Corruption("streamed: CAS offset past end of image".into()))?;
if tail_len > MAX_STREAM_TAIL_BYTES {
return Err(PvError::Corruption(format!(
"streamed: CAS/index/manifest tail exceeds the {MAX_STREAM_TAIL_BYTES}-byte limit"
)));
}
let tail = reader.read_at(cas_offset as u64, tail_len)?;
if tail.len() != tail_len {
return Err(PvError::Corruption(
"streamed: tail range has the wrong length".into(),
));
}
let split = manifest_offset - cas_offset;
if split > tail.len() {
return Err(PvError::Corruption(
"streamed: manifest offset is outside the returned tail".into(),
));
}
let manifest: Manifest = serde_json::from_slice(&tail[split..])?;
check_manifest_version(&manifest)?;
check_header_manifest_version(header.format_version, &manifest)?;
let pool_end = cas_pool_end(&manifest, cas_offset, manifest_offset)? - cas_offset;
let pool = &tail[..pool_end];
if manifest.cas_dir.len() != manifest.cas_hashes.len() {
return Err(PvError::Corruption(
"streamed: CAS dir/hash length mismatch".into(),
));
}
let mut cas = CasStore::new_memory();
for (&(off, len), expected_hash) in manifest.cas_dir.iter().zip(&manifest.cas_hashes) {
let off = usize::try_from(off).map_err(|_| {
PvError::Corruption("streamed: CAS blob offset is too large".into())
})?;
let len = usize::try_from(len).map_err(|_| {
PvError::Corruption("streamed: CAS blob length is too large".into())
})?;
let end = off
.checked_add(len)
.filter(|&e| e <= pool.len())
.ok_or_else(|| PvError::Corruption("streamed: CAS blob out of bounds".into()))?;
let blob = &pool[off..end];
verify_blob_hash_hex(blob, expected_hash)?;
cas.put(blob)?;
}
let region: &[u8] = match manifest.index_region {
None => &[],
Some((off, len)) => {
let off = usize::try_from(off).map_err(|_| {
PvError::Corruption("streamed: index region offset is too large".into())
})?;
let len = usize::try_from(len).map_err(|_| {
PvError::Corruption("streamed: index region length is too large".into())
})?;
let rel = off.checked_sub(cas_offset).ok_or_else(|| {
PvError::Corruption("streamed: index region before CAS pool".into())
})?;
let end = rel
.checked_add(len)
.filter(|&e| e <= tail.len())
.ok_or_else(|| {
PvError::Corruption("streamed: index region out of bounds".into())
})?;
&tail[rel..end]
}
};
let backend = Backend::Remote(RemoteStore::new(reader, page_count));
let mut cache = PageCache::new(backend, DEFAULT_CACHE_PAGES);
let tables = build_tables(&mut cache, &cas, &manifest, false, region)?;
Ok(Self {
cache: RefCell::new(cache),
cas,
txm: TxManager::with_clock(manifest.clock),
tables,
compliance: ComplianceMonitor::new(),
root: None,
autocommit: false,
durability: Durability::Fast,
format_version_floor: manifest.format_version,
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log: None,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
})
}
pub fn open_memory() -> Self {
Self {
cache: RefCell::new(PageCache::new(
Backend::Mem(MemStore::new()),
DEFAULT_CACHE_PAGES,
)),
cas: CasStore::new_memory(),
txm: TxManager::new(),
tables: BTreeMap::new(),
compliance: ComplianceMonitor::new(),
root: None,
autocommit: false,
durability: Durability::Fast,
format_version_floor: FORMAT_VERSION_BASE,
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log: None,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
}
}
pub fn import_bytes(bytes: &[u8]) -> Result<Self> {
let header = FileHeader::decode(bytes)?; let cas_offset = usize::try_from(header.cas_offset)
.map_err(|_| PvError::Corruption("import: CAS offset is too large".into()))?;
let manifest_offset = usize::try_from(header.manifest_offset)
.map_err(|_| PvError::Corruption("import: manifest offset is too large".into()))?;
if cas_offset < FILE_HEADER_SIZE
|| manifest_offset < cas_offset
|| manifest_offset > bytes.len()
|| (cas_offset - FILE_HEADER_SIZE) % PAGE_SIZE != 0
{
return Err(PvError::Corruption("import: inconsistent offsets".into()));
}
let manifest: Manifest = serde_json::from_slice(&bytes[manifest_offset..])?;
check_manifest_version(&manifest)?;
check_header_manifest_version(header.format_version, &manifest)?;
let mem = MemStore::new();
let page_count = (cas_offset - FILE_HEADER_SIZE) / PAGE_SIZE;
for i in 0..page_count {
let start = FILE_HEADER_SIZE + i * PAGE_SIZE;
let page: &[u8; PAGE_SIZE] = bytes[start..start + PAGE_SIZE]
.try_into()
.expect("slice is exactly PAGE_SIZE");
let id = mem.alloc_page();
mem.write_page(id, page)?;
}
if manifest.cas_dir.len() != manifest.cas_hashes.len() {
return Err(PvError::Corruption(
"import: CAS dir/hash length mismatch".into(),
));
}
let pool_end = cas_pool_end(&manifest, cas_offset, manifest_offset)?;
let pool = &bytes[cas_offset..pool_end];
let mut cas = CasStore::new_memory();
for (&(off, len), expected_hash) in manifest.cas_dir.iter().zip(&manifest.cas_hashes) {
let off = usize::try_from(off)
.map_err(|_| PvError::Corruption("import: CAS blob offset is too large".into()))?;
let len = usize::try_from(len)
.map_err(|_| PvError::Corruption("import: CAS blob length is too large".into()))?;
let end = off
.checked_add(len)
.filter(|&e| e <= pool.len())
.ok_or_else(|| PvError::Corruption("import: CAS blob out of bounds".into()))?;
let blob = &pool[off..end];
verify_blob_hash_hex(blob, expected_hash)?;
cas.put(blob)?;
}
let region = slice_index_region(bytes, &manifest, cas_offset as u64, manifest_offset)?;
let mut cache = PageCache::new(Backend::Mem(mem), DEFAULT_CACHE_PAGES);
let tables = build_tables(&mut cache, &cas, &manifest, true, region)?;
Ok(Self {
cache: RefCell::new(cache),
cas,
txm: TxManager::with_clock(manifest.clock),
tables,
compliance: ComplianceMonitor::new(),
root: None,
autocommit: false,
durability: Durability::Fast,
format_version_floor: manifest.format_version,
manifest_file: RefCell::new(None),
active_transaction: None,
commit_log: None,
synced: Cell::new(false),
#[cfg(feature = "enterprise")]
enterprise: crate::enterprise::EnterpriseRuntime::default(),
})
}
pub fn bake_to_bytes(&mut self) -> Result<Vec<u8>> {
self.flush()?;
let pages = self.cache.borrow().backend().read_all_pages()?;
let (cas_pool, _dir) = self.cas.pack()?;
let (region, descs) = self.build_index_region();
let region_offset = (FILE_HEADER_SIZE + pages.len() * PAGE_SIZE + cas_pool.len()) as u64;
let manifest = self.build_manifest(
true,
&IndexPlan::Binary {
descs,
offset: region_offset,
len: region.len() as u64,
},
)?;
let format_version = manifest.format_version;
let json = serde_json::to_vec(&manifest)?;
bake_monolith_bytes_with_index(&pages, &cas_pool, ®ion, &json, format_version)
}
fn build_index_region(&self) -> (Vec<u8>, Vec<(String, Vec<BinIndexDesc>)>) {
let mut region = Vec::new();
let mut all = Vec::new();
for (name, t) in &self.tables {
let mut descs = Vec::new();
for (col, idx) in &t.indexes {
let blob = idx.encode_binary();
let offset = region.len() as u64;
let len = blob.len() as u64;
region.extend_from_slice(&blob);
descs.push(BinIndexDesc {
column: col.clone(),
offset,
len,
});
}
if !descs.is_empty() {
all.push((name.clone(), descs));
}
}
(region, all)
}
pub fn bake(&mut self, out_path: impl AsRef<Path>) -> Result<()> {
let path = out_path.as_ref();
let parent = path
.parent()
.filter(|p| !p.as_os_str().is_empty())
.unwrap_or(Path::new("."));
let mut file = tempfile::NamedTempFile::new_in(parent)?;
self.bake_to_writer(file.as_file_mut())?;
file.as_file().sync_all()?;
file.persist(path).map_err(|e| PvError::Io(e.error))?;
Ok(())
}
pub fn bake_to_writer(&mut self, out: &mut impl Write) -> Result<()> {
self.flush()?;
let page_count = self.cache.borrow().backend().page_count();
let cas_offset = page_count
.checked_mul(PAGE_SIZE as u64)
.and_then(|n| n.checked_add(FILE_HEADER_SIZE as u64))
.ok_or_else(|| PvError::Corruption("image size overflow".into()))?;
let mut cas_dir = Vec::with_capacity(self.cas.len());
let mut cas_size = 0u64;
for id in 0..self.cas.len() as u64 {
let size = self.cas.get(id)?.len() as u64;
cas_dir.push((cas_size, size));
cas_size = cas_size
.checked_add(size)
.ok_or_else(|| PvError::Corruption("CAS size overflow".into()))?;
}
let (region, descs) = self.build_index_region();
let index_offset = cas_offset
.checked_add(cas_size)
.ok_or_else(|| PvError::Corruption("image size overflow".into()))?;
let manifest_offset = index_offset
.checked_add(region.len() as u64)
.ok_or_else(|| PvError::Corruption("image size overflow".into()))?;
let mut manifest = self.build_manifest(
false,
&IndexPlan::Binary {
descs,
offset: index_offset,
len: region.len() as u64,
},
)?;
manifest.cas_dir = cas_dir;
out.write_all(
&FileHeader::new_versioned(manifest_offset, cas_offset, manifest.format_version)
.encode(),
)?;
for id in 0..page_count {
let page = self.cache.borrow().backend().read_page(id)?;
verify_page_checksum(id, &page)?;
out.write_all(&page[..])?;
}
for id in 0..self.cas.len() as u64 {
out.write_all(self.cas.get(id)?)?;
}
out.write_all(®ion)?;
serde_json::to_writer(&mut *out, &manifest)?;
out.flush()?;
Ok(())
}
pub fn bake_resumable(&mut self, out_path: impl AsRef<Path>) -> Result<()> {
let path = out_path.as_ref();
let mut partial = path.as_os_str().to_os_string();
partial.push(".partial");
let partial = PathBuf::from(partial);
if let Ok(metadata) = fs::symlink_metadata(&partial) {
if !metadata.is_file() || metadata.file_type().is_symlink() {
return Err(PvError::Schema(
"bake partial must be a regular file".into(),
));
}
}
let file = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(&partial)?;
#[cfg(not(target_arch = "wasm32"))]
file.try_lock_exclusive()?;
let existing = file.metadata()?.len();
let mut writer = ResumeWriter {
file,
position: 0,
existing,
};
self.bake_to_writer(&mut writer)?;
if writer.position < existing {
return Err(PvError::Corruption(
"bake partial is longer than the expected image".into(),
));
}
writer.file.sync_all()?;
drop(writer);
fs::rename(&partial, path)?;
Ok(())
}
pub fn query_with(&mut self, sql: &str, params: &[Value]) -> Result<QueryResult> {
let bound = crate::engine::query::bind_params(sql, params)?;
self.query(&bound)
}
pub fn prepare(&self, sql: impl Into<String>) -> Result<PreparedStatement> {
let sql = sql.into();
let parameter_count = crate::engine::query::parameter_count(&sql);
let placeholders = vec![Value::Null; parameter_count];
let bound = crate::engine::query::bind_params(&sql, &placeholders)?;
parse(&bound)?;
Ok(PreparedStatement {
sql,
parameter_count,
})
}
pub fn execute_many(&mut self, sql: &str, rows: &[Vec<Value>]) -> Result<usize> {
let prepared = self.prepare(sql)?;
let bound =
crate::engine::query::bind_params(sql, &vec![Value::Null; prepared.parameter_count])?;
if !matches!(
parse(&bound)?,
Statement::Insert { .. }
| Statement::InsertMany { .. }
| Statement::InsertSchema { .. }
| Statement::Update { .. }
| Statement::UpdateDefault { .. }
| Statement::Delete { .. }
) {
return Err(PvError::Query(
"execute_many expects INSERT, UPDATE or DELETE".into(),
));
}
if self.in_transaction() {
return Err(PvError::Transaction(
"execute_many owns its transaction; call it outside an active transaction".into(),
));
}
for row in rows {
if row.len() != prepared.parameter_count {
return Err(PvError::Schema(format!(
"batch row expects {} parameters, got {}",
prepared.parameter_count,
row.len()
)));
}
}
if rows.is_empty() {
return Ok(0);
}
self.transaction(|db| {
let mut affected = 0usize;
for row in rows {
if let QueryResult::Mutated(count) = prepared.execute(db, row)? {
affected = affected.checked_add(count).ok_or_else(|| {
PvError::ResourceLimit("batch affected-row count overflow".into())
})?;
}
}
Ok(affected)
})
}
pub fn transaction<T>(
&mut self,
operation: impl FnOnce(&mut Database) -> Result<T>,
) -> Result<T> {
self.begin_transaction()?;
match operation(self) {
Ok(value) => {
if !self.in_transaction() {
return Err(PvError::Transaction(
"transaction callback changed the transaction state".into(),
));
}
match self.commit_transaction() {
Ok(()) => Ok(value),
Err(commit_error) => {
if !self.in_transaction() {
return Err(commit_error);
}
match self.rollback_transaction() {
Ok(()) => Err(commit_error),
Err(rollback_error) => Err(PvError::TransactionOutcomeUnknown(
format!(
"commit failed ({commit_error}); rollback also failed ({rollback_error})"
),
)),
}
}
}
}
Err(error) => {
if self.in_transaction() {
self.rollback_transaction().map_err(|rollback_error| {
PvError::TransactionOutcomeUnknown(format!(
"operation failed ({error}); rollback also failed ({rollback_error})"
))
})?;
}
Err(error)
}
}
}
pub fn begin_transaction(&mut self) -> Result<()> {
if !self.cache.borrow().is_writable() {
return Err(PvError::ReadOnly);
}
if self.active_transaction.is_some() {
return Err(PvError::Transaction(
"a transaction is already active".into(),
));
}
let previous_autocommit = self.autocommit;
let previous_durability = self.durability;
let (rollback, filesystem_lock) = if let Some(root) = self.root.clone() {
let lock = acquire_transaction_lock(&root)?;
self.durability = Durability::Sync;
if !(self.commit_log.is_some() && self.synced.get()) {
if let Err(error) = self.flush() {
self.durability = previous_durability;
return Err(error);
}
}
self.durability = previous_durability;
if let Some(options) = self.commit_log {
match self.cache.borrow().backend() {
Backend::Dev(dev) => dev.begin_journal(options)?,
_ => return Err(PvError::ReadOnly),
}
(TransactionRollback::Journal(root), Some(lock))
} else {
let marker_preexisted = root.join(TRANSACTION_MARKER_FILE).exists();
if let Err(prepare_error) = prepare_workspace_transaction(&root) {
if marker_preexisted {
return Err(prepare_error);
}
let cleanup = abort_workspace_transaction_preparation(&root);
return match cleanup {
Ok(()) => Err(prepare_error),
Err(cleanup_error) => Err(PvError::TransactionOutcomeUnknown(format!(
"transaction preparation failed ({prepare_error}); recovery-artifact cleanup also failed ({cleanup_error})"
))),
};
}
(TransactionRollback::Filesystem(root), Some(lock))
}
} else {
(TransactionRollback::Memory(self.bake_to_bytes()?), None)
};
self.autocommit = false;
self.active_transaction = Some(ActiveTransaction {
rollback,
previous_autocommit,
previous_durability,
_filesystem_lock: filesystem_lock,
});
#[cfg(feature = "enterprise")]
self.enterprise.emit(crate::enterprise::AuditEvent::pending(
crate::enterprise::AuditEventKind::TransactionBegan,
self.current_tx(),
));
Ok(())
}
pub fn commit_transaction(&mut self) -> Result<()> {
let (filesystem_root, previous_durability) = match self.active_transaction.as_ref() {
Some(state) => (
match &state.rollback {
TransactionRollback::Filesystem(root) | TransactionRollback::Journal(root) => {
Some(root.clone())
}
TransactionRollback::Memory(_) => None,
},
state.previous_durability,
),
None => return Err(PvError::Transaction("no transaction is active".into())),
};
if filesystem_root.is_some() {
self.durability = Durability::Sync;
}
if let Err(error) = self.flush() {
self.durability = previous_durability;
return Err(error);
}
let commit_point_error = if let Some(root) = &filesystem_root {
let result = if matches!(
self.active_transaction.as_ref().map(|s| &s.rollback),
Some(TransactionRollback::Journal(_))
) {
match self.cache.borrow().backend() {
Backend::Dev(dev) => dev.commit_journal(),
_ => Err(PvError::ReadOnly),
}
} else {
commit_workspace_transaction(root)
};
match result {
Ok(()) => None,
Err(error @ PvError::TransactionOutcomeUnknown(_)) => Some(error),
Err(error) => return Err(error),
}
} else {
None
};
let state = self
.active_transaction
.take()
.expect("transaction state checked above");
self.autocommit = state.previous_autocommit;
self.durability = state.previous_durability;
if let Some(error) = commit_point_error {
return Err(error);
}
if let TransactionRollback::Filesystem(root) = state.rollback {
let _ = fs::remove_dir_all(root.join(TRANSACTION_BACKUP_DIR));
}
#[cfg(feature = "enterprise")]
self.enterprise.emit(crate::enterprise::AuditEvent::pending(
crate::enterprise::AuditEventKind::TransactionCommitted,
self.current_tx(),
));
Ok(())
}
pub fn rollback_transaction(&mut self) -> Result<()> {
let Some(mut state) = self.active_transaction.take() else {
return Err(PvError::Transaction("no transaction is active".into()));
};
let commit_log = self.commit_log;
let rollback = (|| -> Result<()> {
#[cfg(feature = "enterprise")]
let enterprise = self.enterprise.clone();
match state.rollback {
TransactionRollback::Memory(snapshot) => {
let mut restored = Database::import_bytes(&snapshot)?;
restored.commit_log = commit_log;
restored.autocommit = state.previous_autocommit;
restored.durability = state.previous_durability;
#[cfg(feature = "enterprise")]
{
restored.enterprise = enterprise;
restored
.enterprise
.emit(crate::enterprise::AuditEvent::pending(
crate::enterprise::AuditEventKind::TransactionRolledBack,
restored.current_tx(),
));
}
*self = restored;
}
TransactionRollback::Filesystem(ref root)
| TransactionRollback::Journal(ref root) => {
let root = root.clone();
let journaled = matches!(state.rollback, TransactionRollback::Journal(_));
*self = Database::open_memory();
if journaled {
if !root
.join(crate::COMMIT_LOG_DIR)
.join("active/header")
.is_file()
{
return Err(PvError::TransactionOutcomeUnknown(
"active page journal is missing".into(),
));
}
crate::journal::recover(&root)?;
} else {
restore_workspace_transaction(&root)?;
}
drop(state._filesystem_lock.take());
let mut restored = Database::open_dev(&root)?;
restored.commit_log = commit_log;
restored.autocommit = state.previous_autocommit;
restored.durability = state.previous_durability;
#[cfg(feature = "enterprise")]
{
restored.enterprise = enterprise;
restored
.enterprise
.emit(crate::enterprise::AuditEvent::pending(
crate::enterprise::AuditEventKind::TransactionRolledBack,
restored.current_tx(),
));
}
*self = restored;
}
}
Ok(())
})();
rollback.map_err(|error| {
if matches!(&error, PvError::TransactionOutcomeUnknown(_)) {
error
} else {
PvError::TransactionOutcomeUnknown(format!(
"transaction rollback failed after consuming its recovery state ({error})"
))
}
})
}
pub fn in_transaction(&self) -> bool {
self.active_transaction.is_some()
}
fn atomic_mutation<T>(
&mut self,
operation: impl FnOnce(&mut Database) -> Result<T>,
) -> Result<T> {
if !self.in_transaction() {
return self.transaction(operation);
}
match operation(self) {
Ok(value) => Ok(value),
Err(error) => {
self.rollback_transaction().map_err(|rollback_error| {
PvError::TransactionOutcomeUnknown(format!(
"statement failed ({error}); transaction rollback also failed ({rollback_error})"
))
})?;
Err(error)
}
}
}
pub fn query_with_limits(
&mut self,
sql: &str,
params: &[Value],
limits: QueryLimits,
) -> Result<QueryResult> {
self.query_with_limits_cancellable(sql, params, limits, None)
}
pub(crate) fn query_with_limits_cancellable(
&mut self,
sql: &str,
params: &[Value],
limits: QueryLimits,
cancellation: Option<CancellationToken>,
) -> Result<QueryResult> {
let bound = crate::engine::query::bind_params(sql, params)?;
let mut budget = QueryBudget::new_cancellable(limits, cancellation);
budget.checkpoint()?;
let result = self.execute_statement(parse(&bound)?, Some(&mut budget))?;
budget.check_result(&result)?;
Ok(result)
}
pub fn query(&mut self, sql: &str) -> Result<QueryResult> {
self.execute_statement(parse(sql)?, None)
}
fn execute_statement(
&mut self,
statement: Statement,
mut budget: Option<&mut QueryBudget>,
) -> Result<QueryResult> {
if self.commit_log.is_some()
&& !self.in_transaction()
&& !matches!(
&statement,
Statement::Select { .. }
| Statement::SelectJoin { .. }
| Statement::Explain { .. }
| Statement::Begin
| Statement::Commit
| Statement::Rollback
)
{
return self.transaction(move |database| database.execute_statement(statement, budget));
}
match statement {
Statement::Explain { statement } => {
let result = self.explain_statement(&statement, budget.is_some())?;
if let (Some(budget), QueryResult::Rows { rows, .. }) = (budget, &result) {
for row in rows {
budget.materialize(row)?;
}
}
Ok(result)
}
Statement::Begin => {
self.begin_transaction()?;
Ok(QueryResult::Done)
}
Statement::Commit => {
self.commit_transaction()?;
Ok(QueryResult::Done)
}
Statement::Rollback => {
self.rollback_transaction()?;
Ok(QueryResult::Done)
}
Statement::CreateTable {
name,
columns,
unique_columns,
not_null_columns,
} => {
self.create_table_with_constraints(
&name,
columns,
unique_columns,
not_null_columns,
)?;
Ok(QueryResult::Done)
}
Statement::CreateTableIfNotExists {
name,
columns,
unique_columns,
not_null_columns,
} => {
if !self.tables.contains_key(&name) {
self.create_table_with_constraints(
&name,
columns,
unique_columns,
not_null_columns,
)?;
}
Ok(QueryResult::Done)
}
Statement::CreateTableSchema {
name,
columns,
checks,
if_not_exists,
} => {
if !if_not_exists || !self.tables.contains_key(&name) {
self.create_table_schema(&name, columns, checks)?;
}
Ok(QueryResult::Done)
}
Statement::CreateIndex {
table,
column,
unique,
} => {
if unique {
self.validate_unique(&table, &column, budget.as_deref_mut())?;
}
self.create_index_bounded(&table, &column, budget.as_deref_mut())?;
if unique {
self.tables
.get_mut(&table)
.expect("existence checked")
.unique_columns
.insert(column);
self.maybe_flush()?;
}
Ok(QueryResult::Done)
}
Statement::Insert { table, values } => {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&values)?;
budget.checkpoint()?;
}
self.ensure_writable()?;
self.validate_insert_values(&table, &values, None, budget.as_deref_mut())?;
self.insert_validated(&table, values)?;
Ok(QueryResult::Mutated(1))
}
Statement::InsertMany { table, rows } => {
self.ensure_writable()?;
let count = rows.len();
let mut pending = BTreeMap::new();
for values in &rows {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(values)?;
}
self.validate_insert_values(
&table,
values,
Some(&mut pending),
budget.as_deref_mut(),
)?;
}
if let Some(budget) = budget.as_deref_mut() {
budget.checkpoint()?;
}
if count > 1 {
self.atomic_mutation(move |database| {
for values in rows {
database.insert_validated(&table, values)?;
}
Ok(())
})?;
} else {
for values in rows {
self.insert_validated(&table, values)?;
}
}
Ok(QueryResult::Mutated(count))
}
Statement::InsertSchema {
table,
target_columns,
rows,
} => {
self.ensure_writable()?;
let count = rows.len();
let mut normalized = Vec::with_capacity(count);
let mut pending = BTreeMap::new();
for row in rows {
let values =
self.normalize_insert_values(&table, target_columns.as_deref(), row)?;
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&values)?;
}
self.validate_insert_values(
&table,
&values,
Some(&mut pending),
budget.as_deref_mut(),
)?;
normalized.push(values);
}
if let Some(budget) = budget.as_deref_mut() {
budget.checkpoint()?;
}
if count > 1 {
self.atomic_mutation(move |database| {
for values in normalized {
database.insert_validated(&table, values)?;
}
Ok(())
})?;
} else {
for values in normalized {
self.insert_validated(&table, values)?;
}
self.maybe_flush()?;
}
Ok(QueryResult::Mutated(count))
}
Statement::Select {
table,
projection,
distinct,
before,
filter,
group_by,
having,
order,
limit,
offset,
} => {
if filter.is_none()
&& group_by.is_empty()
&& having.is_none()
&& order.is_empty()
&& limit.is_none()
&& offset == 0
&& !distinct
{
if let Some(alias) = count_star_only(&projection) {
let n = self.count_visible(&table, before, budget.as_deref_mut())?;
return Ok(QueryResult::Rows {
columns: vec![alias.unwrap_or_else(|| "count".into())],
rows: vec![vec![Value::Int(n as i64)]],
});
}
}
let grouped = !group_by.is_empty()
|| projection_has_aggregate(&projection)
|| having.is_some();
if grouped && filter.is_none() && having.is_none() {
return self.select_streaming_aggregate(
&table,
before,
projection_to_items(projection)?,
group_by,
order,
distinct,
limit,
offset,
budget.as_deref_mut(),
);
}
if !grouped && filter.is_none() && !distinct && order.len() == 1 {
let ob = &order[0];
if self.has_index(&table, &ob.column) {
let (columns, rows) = self.select_ordered_by_index(
&table,
ob,
before,
limit.map(|n| n.saturating_add(offset)),
budget.as_deref_mut(),
)?;
return project_select(
columns,
rows,
projection,
&[],
false,
limit,
offset,
);
}
}
let (columns, rows) = self.select_filtered_bounded(
&table,
filter.as_ref(),
before,
budget.as_deref_mut(),
)?;
if grouped {
let items = projection_to_items(projection)?;
project_grouped(
columns, rows, items, group_by, having, order, distinct, limit, offset,
)
} else {
project_select(columns, rows, projection, &order, distinct, limit, offset)
}
}
Statement::SelectJoin {
projection,
distinct,
source,
joins,
before,
filter,
group_by,
having,
order,
limit,
offset,
} => self.select_join(
&source,
&joins,
before,
projection,
distinct,
filter.as_ref(),
group_by,
having,
&order,
limit,
offset,
budget.as_deref_mut(),
),
Statement::Update { table, set, filter } => {
let n = self.update_where_bounded(
&table,
&set.0,
&set.1,
&filter,
budget.as_deref_mut(),
)?;
Ok(QueryResult::Mutated(n))
}
Statement::UpdateDefault {
table,
column,
filter,
} => {
let value = self
.tables
.get(&table)
.ok_or_else(|| PvError::TableNotFound(table.clone()))?
.defaults
.get(&column)
.cloned()
.unwrap_or(Value::Null);
let n = self.update_where_bounded(
&table,
&column,
&value,
&filter,
budget.as_deref_mut(),
)?;
Ok(QueryResult::Mutated(n))
}
Statement::Delete { table, filter } => {
let n = self.delete_where_bounded(&table, &filter, budget)?;
Ok(QueryResult::Mutated(n))
}
Statement::DropTable { table } => {
self.drop_table(&table)?;
Ok(QueryResult::Done)
}
Statement::DropTableIfExists { table } => {
if self.tables.contains_key(&table) {
self.drop_table(&table)?;
}
Ok(QueryResult::Done)
}
}
}
pub fn create_table(&mut self, name: &str, columns: Vec<String>) -> Result<()> {
self.create_table_with_constraints(name, columns, Vec::new(), Vec::new())
}
fn create_table_with_constraints(
&mut self,
name: &str,
columns: Vec<String>,
unique_columns: Vec<String>,
not_null_columns: Vec<String>,
) -> Result<()> {
self.create_table_internal(
name,
columns,
unique_columns,
not_null_columns,
BTreeMap::new(),
Vec::new(),
)
}
fn create_table_schema(
&mut self,
name: &str,
definitions: Vec<ColumnDefinition>,
checks: Vec<Predicate>,
) -> Result<()> {
let columns = definitions
.iter()
.map(|definition| definition.name.clone())
.collect();
let unique_columns = definitions
.iter()
.filter(|definition| definition.unique)
.map(|definition| definition.name.clone())
.collect();
let not_null_columns = definitions
.iter()
.filter(|definition| definition.not_null)
.map(|definition| definition.name.clone())
.collect::<Vec<_>>();
let defaults = definitions
.into_iter()
.filter_map(|definition| definition.default.map(|value| (definition.name, value)))
.collect();
self.create_table_internal(
name,
columns,
unique_columns,
not_null_columns,
defaults,
checks,
)
}
fn create_table_internal(
&mut self,
name: &str,
columns: Vec<String>,
unique_columns: Vec<String>,
not_null_columns: Vec<String>,
defaults: BTreeMap<String, Value>,
checks: Vec<Predicate>,
) -> Result<()> {
self.ensure_writable()?;
if self.tables.contains_key(name) {
return Err(PvError::Schema(format!("table `{name}` already exists")));
}
validate_schema_metadata(
name,
&columns,
&unique_columns,
¬_null_columns,
&defaults,
&checks,
false,
)?;
self.tables.insert(
name.to_string(),
Table {
columns,
indexes: unique_columns
.iter()
.map(|column| (column.clone(), SecondaryIndex::new()))
.collect(),
unique_columns: unique_columns.into_iter().collect(),
not_null_columns: not_null_columns.into_iter().collect(),
defaults,
checks,
first_page: None,
tail_id: None,
tail: None,
row_versions: 0,
cold_pages: 0,
compaction_cursor: None,
page_ids: RefCell::new(None),
},
);
self.maybe_flush()
}
fn validate_unique(
&self,
table_name: &str,
column: &str,
budget: Option<&mut QueryBudget>,
) -> Result<()> {
let (_, rows) = self.select_filtered_bounded(table_name, None, None, budget)?;
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let ix = column_index(table, column)?;
let mut seen: Vec<Value> = Vec::new();
for row in rows {
if row[ix] != Value::Null {
if seen.iter().any(|value| values_equal(value, &row[ix])) {
return Err(PvError::Schema(format!(
"cannot create unique index: duplicate value in `{column}`"
)));
}
seen.push(row[ix].clone());
}
}
Ok(())
}
pub fn create_index(&mut self, table_name: &str, column: &str) -> Result<()> {
self.create_index_bounded(table_name, column, None)
}
fn create_index_bounded(
&mut self,
table_name: &str,
column: &str,
mut budget: Option<&mut QueryBudget>,
) -> Result<()> {
self.ensure_writable()?;
let mut index = SecondaryIndex::new();
{
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let col_ix = column_index(table, column)?;
let mut cache = self.cache.borrow_mut();
scan(&mut cache, table, &self.cas, |addr, _env, row| {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
budget.materialize(row)?;
}
index.insert(&row[col_ix], addr);
Ok(())
})?;
}
if let Some(budget) = budget {
budget.checkpoint()?;
}
self.tables
.get_mut(table_name)
.expect("existence checked above")
.indexes
.insert(column.to_string(), index);
self.maybe_flush()
}
pub fn insert(&mut self, table_name: &str, values: Vec<Value>) -> Result<()> {
self.ensure_writable()?;
self.validate_insert_values(table_name, &values, None, None)?;
self.insert_validated(table_name, values)
}
fn normalize_insert_values(
&self,
table_name: &str,
target_columns: Option<&[String]>,
row: Vec<InsertValue>,
) -> Result<Vec<Value>> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let value_for = |column: &str, value: InsertValue| match value {
InsertValue::Literal(value) => value,
InsertValue::Default => table.defaults.get(column).cloned().unwrap_or(Value::Null),
};
match target_columns {
None => {
if row.len() != table.columns.len() {
return Err(PvError::Schema(format!(
"table `{table_name}` expects {} columns, got {}",
table.columns.len(),
row.len()
)));
}
Ok(table
.columns
.iter()
.zip(row)
.map(|(column, value)| value_for(column, value))
.collect())
}
Some(targets) => {
if row.len() != targets.len() {
return Err(PvError::Schema(format!(
"INSERT target list has {} columns but row has {} values",
targets.len(),
row.len()
)));
}
let mut values = table
.columns
.iter()
.map(|column| table.defaults.get(column).cloned().unwrap_or(Value::Null))
.collect::<Vec<_>>();
let mut seen = BTreeSet::new();
for (target, value) in targets.iter().zip(row) {
if !seen.insert(target) {
return Err(PvError::Schema(format!(
"duplicate INSERT target column `{target}`"
)));
}
let index = column_index(table, target)?;
values[index] = value_for(target, value);
}
Ok(values)
}
}
}
fn validate_insert_values(
&self,
table_name: &str,
values: &[Value],
mut pending: Option<&mut BTreeMap<String, BTreeSet<Value>>>,
mut budget: Option<&mut QueryBudget>,
) -> Result<()> {
self.validate_row_constraints(table_name, values)?;
let (columns, unique_columns) = {
let table = self.tables.get(table_name).expect("existence checked");
(table.columns.clone(), table.unique_columns.clone())
};
for column in &unique_columns {
let ix = col_pos(&columns, column)?;
if values[ix] != Value::Null {
if let Some(pending) = pending.as_deref_mut() {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
if !pending
.entry(column.clone())
.or_default()
.insert(join_key(&values[ix]))
{
return Err(PvError::Schema(format!(
"duplicate value for unique column `{column}`"
)));
}
}
let predicate = Predicate::eq(column, values[ix].clone());
let duplicate_existing = !self
.select_filtered_bounded(
table_name,
Some(&predicate),
None,
budget.as_deref_mut(),
)?
.1
.is_empty();
if duplicate_existing {
return Err(PvError::Schema(format!(
"duplicate value for unique column `{column}`"
)));
}
}
}
Ok(())
}
fn validate_row_constraints(&self, table_name: &str, values: &[Value]) -> Result<()> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
if values.len() != table.columns.len() {
return Err(PvError::Schema(format!(
"table `{table_name}` expects {} columns, got {}",
table.columns.len(),
values.len()
)));
}
validate_record_shape(values)?;
for column in &table.not_null_columns {
let index = col_pos(&table.columns, column)?;
if values[index] == Value::Null {
return Err(PvError::Schema(format!(
"column `{column}` may not be NULL"
)));
}
}
for (index, check) in table.checks.iter().enumerate() {
if check_result(check, &table.columns, values)? == Some(false) {
return Err(PvError::Schema(format!(
"CHECK constraint {} failed on table `{table_name}`",
index + 1
)));
}
}
Ok(())
}
fn insert_validated(&mut self, table_name: &str, values: Vec<Value>) -> Result<()> {
self.ensure_writable()?;
validate_record_shape(&values)?;
let tx = self.txm.begin_write();
let envelope = RecordEnvelope::new(tx, 0);
let record = encode_record(&envelope, &values, &mut self.cas)?;
if record.len() > MAX_RECORD {
return Err(PvError::Schema(format!(
"record of {} bytes exceeds page capacity ({MAX_RECORD})",
record.len()
)));
}
let addr = {
let mut cache = self.cache.borrow_mut();
let table = self.tables.get_mut(table_name).expect("existence checked");
append_record(&mut cache, table, &record)?
};
let table = self.tables.get_mut(table_name).expect("existence checked");
if !table.indexes.is_empty() {
let indexed: Vec<usize> = table
.columns
.iter()
.enumerate()
.filter(|(_, c)| table.indexes.contains_key(*c))
.map(|(i, _)| i)
.collect();
for ix in indexed {
if let Some(index) = table.indexes.get_mut(&table.columns[ix]) {
index.insert(&values[ix], addr);
}
}
}
self.maybe_flush()
}
pub fn delete(&mut self, table_name: &str, column: &str, value: &Value) -> Result<usize> {
self.delete_where(table_name, &Predicate::eq(column, value.clone()))
}
pub fn delete_where(&mut self, table_name: &str, pred: &Predicate) -> Result<usize> {
self.delete_where_bounded(table_name, pred, None)
}
fn delete_where_bounded(
&mut self,
table_name: &str,
pred: &Predicate,
mut budget: Option<&mut QueryBudget>,
) -> Result<usize> {
self.ensure_writable()?;
let snapshot = self.txm.snapshot();
let matches = self.collect_matching(table_name, pred, &snapshot, budget.as_deref_mut())?;
if let Some(budget) = budget {
budget.checkpoint()?;
}
if matches.len() > 1 {
let table_name = table_name.to_string();
return self
.atomic_mutation(move |database| database.apply_deletes(&table_name, &matches));
}
self.apply_deletes(table_name, &matches)
}
fn apply_deletes(&mut self, table_name: &str, matches: &[(RecordAddr, Row)]) -> Result<usize> {
let tx = self.txm.begin_write();
let table = self.tables.get_mut(table_name).expect("existence checked");
{
let mut cache = self.cache.borrow_mut();
for (addr, _) in matches {
patch_delete_at(&mut cache, table, *addr, tx)?;
}
}
self.maybe_flush()?;
Ok(matches.len())
}
fn collect_matching(
&self,
table_name: &str,
pred: &Predicate,
snapshot: &Snapshot,
mut budget: Option<&mut QueryBudget>,
) -> Result<Vec<(RecordAddr, Row)>> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let columns = table.columns.clone();
check_predicate_columns(&columns, pred)?;
let mut hits: Vec<(RecordAddr, Row)> = Vec::new();
let mut cache = self.cache.borrow_mut();
if let Some(addrs) = index_candidates(table, pred, budget.as_deref_mut())? {
for addr in addrs {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
let (env, row) = read_record_at(&mut cache, table, &self.cas, addr)?;
if snapshot.sees(&env) && row_matches(pred, &columns, &row)? {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
hits.push((addr, row));
}
}
} else {
scan(&mut cache, table, &self.cas, |addr, env, row| {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
if snapshot.sees(env) && row_matches(pred, &columns, row)? {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(row)?;
}
hits.push((addr, row.clone()));
}
Ok(())
})?;
}
Ok(hits)
}
pub fn select(&self, table_name: &str, before: Option<u64>) -> Result<(Vec<String>, Vec<Row>)> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let columns = table.columns.clone();
let mut rows = Vec::new();
let mut cache = self.cache.borrow_mut();
scan(&mut cache, table, &self.cas, |_addr, env, row| {
if snapshot.sees(env) {
rows.push(row.clone());
}
Ok(())
})?;
Ok((columns, rows))
}
#[allow(clippy::too_many_arguments)] fn select_join(
&self,
source: &TableRef,
joins: &[JoinClause],
before: Option<u64>,
projection: Projection,
distinct: bool,
filter: Option<&Predicate>,
group_by: Vec<String>,
having: Option<HavingPred>,
order: &[OrderBy],
limit: Option<usize>,
offset: usize,
mut budget: Option<&mut QueryBudget>,
) -> Result<QueryResult> {
let source_filter = filter.and_then(|pred| source_predicate(pred, source.qualifier()));
let (source_columns, mut rows) = self.select_filtered_bounded(
&source.name,
source_filter.as_ref(),
before,
budget.as_deref_mut(),
)?;
let mut columns: Vec<String> = source_columns
.into_iter()
.map(|column| format!("{}.{}", source.qualifier(), column))
.collect();
for join in joins {
let right_columns = self.column_names(&join.table.name)?;
let qualified_right: Vec<String> = right_columns
.iter()
.map(|column| format!("{}.{}", join.table.qualifier(), column))
.collect();
let (left_key, right_key) = resolve_join_keys(
&columns,
&qualified_right,
&join.first_column,
&join.second_column,
)?;
let mut probe_keys = BTreeSet::new();
for row in &rows {
if row[left_key] == Value::Null {
continue;
}
let key = join_key(&row[left_key]);
if !probe_keys.contains(&key) {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize_value(&key, "join probe keys")?;
}
probe_keys.insert(key);
}
}
let bounded = budget.is_some();
let mut right_by_key = self.indexed_join_map(
&join.table.name,
right_key,
&probe_keys,
before,
budget.as_deref_mut(),
bounded,
)?;
if right_by_key.is_none() {
let (_, right_rows) = self.select_filtered_bounded(
&join.table.name,
None,
before,
budget.as_deref_mut(),
)?;
let mut map: BTreeMap<Value, Vec<Row>> = BTreeMap::new();
for row in right_rows {
if row[right_key] != Value::Null {
map.entry(join_key(&row[right_key])).or_default().push(row);
}
}
right_by_key = Some(map);
}
let right_by_key = right_by_key.expect("scan or index always produces a map");
let mut joined_rows = Vec::new();
for left in &rows {
let matches = if left[left_key] == Value::Null {
None
} else {
right_by_key.get(&join_key(&left[left_key]))
};
if let Some(matches) = matches {
for right in matches {
let mut row = left.clone();
row.extend_from_slice(right);
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
joined_rows.push(row);
}
} else if join.left_join {
let mut row = left.clone();
row.resize(row.len() + right_columns.len(), Value::Null);
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
joined_rows.push(row);
}
}
columns.extend(qualified_right);
rows = joined_rows;
}
if let Some(filter) = filter {
check_predicate_columns(&columns, filter)?;
rows = rows
.into_iter()
.filter_map(|row| match row_matches(filter, &columns, &row) {
Ok(true) => Some(Ok(row)),
Ok(false) => None,
Err(error) => Some(Err(error)),
})
.collect::<Result<Vec<_>>>()?;
}
let grouped =
!group_by.is_empty() || projection_has_aggregate(&projection) || having.is_some();
if grouped {
let items = projection_to_items(projection)?;
project_grouped(
columns,
rows,
items,
group_by,
having,
order.to_vec(),
distinct,
limit,
offset,
)
} else {
project_select(columns, rows, projection, order, distinct, limit, offset)
}
}
fn indexed_join_map(
&self,
table_name: &str,
right_key: usize,
probe_keys: &BTreeSet<Value>,
before: Option<u64>,
mut budget: Option<&mut QueryBudget>,
bounded: bool,
) -> Result<Option<BTreeMap<Value, Vec<Row>>>> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let column = table.columns.get(right_key).ok_or_else(|| {
PvError::Corruption("join key is outside the right table schema".into())
})?;
let Some(index) = table.indexes.get(column) else {
return Ok(None);
};
let row_versions = usize::try_from(table.row_versions).unwrap_or(usize::MAX);
if !bounded && probe_keys.len().saturating_mul(4) > row_versions.max(1) {
return Ok(None);
}
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let mut cache = self.cache.borrow_mut();
let mut map = BTreeMap::<Value, Vec<Row>>::new();
for key in probe_keys {
let mut addresses = index_equality_candidates(index, key, budget.as_deref_mut())?;
addresses.sort_unstable();
addresses.dedup();
for address in addresses {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
let (envelope, row) = read_record_at(&mut cache, table, &self.cas, address)?;
if snapshot.sees(&envelope)
&& row[right_key] != Value::Null
&& join_key(&row[right_key]) == *key
{
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
map.entry(key.clone()).or_default().push(row);
}
}
}
Ok(Some(map))
}
pub fn column_names(&self, table_name: &str) -> Result<Vec<String>> {
self.tables
.get(table_name)
.map(|t| t.columns.clone())
.ok_or_else(|| PvError::TableNotFound(table_name.into()))
}
pub fn for_each_row<F>(&self, table_name: &str, before: Option<u64>, mut visit: F) -> Result<()>
where
F: FnMut(&Row) -> Result<()>,
{
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let mut cache = self.cache.borrow_mut();
scan(&mut cache, table, &self.cas, |_addr, env, row| {
if snapshot.sees(env) {
visit(row)
} else {
Ok(())
}
})
}
pub fn select_where(
&self,
table_name: &str,
column: &str,
value: &Value,
before: Option<u64>,
) -> Result<(Vec<String>, Vec<Row>)> {
self.select_filtered(
table_name,
Some(&Predicate::eq(column, value.clone())),
before,
)
}
pub fn select_filtered(
&self,
table_name: &str,
filter: Option<&Predicate>,
before: Option<u64>,
) -> Result<(Vec<String>, Vec<Row>)> {
self.select_filtered_bounded(table_name, filter, before, None)
}
fn select_filtered_bounded(
&self,
table_name: &str,
filter: Option<&Predicate>,
before: Option<u64>,
mut budget: Option<&mut QueryBudget>,
) -> Result<(Vec<String>, Vec<Row>)> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let columns = table.columns.clone();
let mut rows = Vec::new();
let mut cache = self.cache.borrow_mut();
match filter {
None => {
scan(&mut cache, table, &self.cas, |_a, env, row| {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
if snapshot.sees(env) {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(row)?;
}
rows.push(row.clone());
}
Ok(())
})?;
}
Some(pred) => {
check_predicate_columns(&columns, pred)?;
if let Some(addrs) = index_candidates(table, pred, budget.as_deref_mut())? {
for addr in addrs {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
let (env, row) = read_record_at(&mut cache, table, &self.cas, addr)?;
if snapshot.sees(&env) && row_matches(pred, &columns, &row)? {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
rows.push(row);
}
}
} else {
scan(&mut cache, table, &self.cas, |_a, env, row| {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
if snapshot.sees(env) && row_matches(pred, &columns, row)? {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(row)?;
}
rows.push(row.clone());
}
Ok(())
})?;
}
}
}
Ok((columns, rows))
}
fn count_visible(
&self,
table_name: &str,
before: Option<u64>,
mut budget: Option<&mut QueryBudget>,
) -> Result<u64> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let mut count = 0u64;
let mut cache = self.cache.borrow_mut();
scan_envelopes(&mut cache, table, |env| {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
if snapshot.sees(env) {
count += 1;
}
Ok(())
})?;
Ok(count)
}
fn has_index(&self, table_name: &str, column: &str) -> bool {
self.tables
.get(table_name)
.is_some_and(|t| t.indexes.contains_key(column))
}
fn select_ordered_by_index(
&self,
table_name: &str,
ob: &OrderBy,
before: Option<u64>,
limit: Option<usize>,
mut budget: Option<&mut QueryBudget>,
) -> Result<(Vec<String>, Vec<Row>)> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let index = table
.indexes
.get(&ob.column)
.expect("caller checked the column is indexed");
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let columns = table.columns.clone();
let mut rows = Vec::new();
let mut cache = self.cache.borrow_mut();
for addr in index.ordered_addrs(ob.descending) {
if let Some(budget) = budget.as_deref_mut() {
budget.scan_row()?;
}
let (env, row) = read_record_at(&mut cache, table, &self.cas, addr)?;
if snapshot.sees(&env) {
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&row)?;
}
rows.push(row);
if limit.is_some_and(|n| rows.len() >= n) {
break;
}
}
}
Ok((columns, rows))
}
pub fn update(
&mut self,
table_name: &str,
set_column: &str,
set_value: &Value,
where_column: &str,
where_value: &Value,
) -> Result<usize> {
self.update_where(
table_name,
set_column,
set_value,
&Predicate::eq(where_column, where_value.clone()),
)
}
pub fn update_where(
&mut self,
table_name: &str,
set_column: &str,
set_value: &Value,
pred: &Predicate,
) -> Result<usize> {
self.update_where_bounded(table_name, set_column, set_value, pred, None)
}
fn update_where_bounded(
&mut self,
table_name: &str,
set_column: &str,
set_value: &Value,
pred: &Predicate,
mut budget: Option<&mut QueryBudget>,
) -> Result<usize> {
self.ensure_writable()?;
let set_ix = {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
column_index(table, set_column)?
};
let snapshot = self.txm.snapshot();
let matches = self.collect_matching(table_name, pred, &snapshot, budget.as_deref_mut())?;
let count = matches.len();
if count == 0 {
return Ok(0);
}
let (is_unique, is_not_null) = {
let table = self.tables.get(table_name).expect("existence checked");
(
table.unique_columns.contains(set_column),
table.not_null_columns.contains(set_column),
)
};
if is_not_null && *set_value == Value::Null {
return Err(PvError::Schema(format!(
"column `{set_column}` may not be NULL"
)));
}
if is_unique && *set_value != Value::Null {
let already_matching = matches
.iter()
.filter(|(_, row)| values_equal(&row[set_ix], set_value))
.count();
let unique_predicate = Predicate::eq(set_column, set_value.clone());
let existing = self
.select_filtered_bounded(
table_name,
Some(&unique_predicate),
None,
budget.as_deref_mut(),
)?
.1
.len();
if count > 1 || existing > already_matching {
return Err(PvError::Schema(format!(
"duplicate value for unique column `{set_column}`"
)));
}
}
for (_, row) in &matches {
let mut replacement = row.clone();
replacement[set_ix] = set_value.clone();
if let Some(budget) = budget.as_deref_mut() {
budget.materialize(&replacement)?;
}
self.validate_row_constraints(table_name, &replacement)?;
}
if let Some(budget) = budget {
budget.checkpoint()?;
}
let table_name = table_name.to_string();
let set_value = set_value.clone();
self.atomic_mutation(move |database| {
let del_tx = database.txm.begin_write();
{
let table = database
.tables
.get_mut(&table_name)
.expect("existence checked");
let mut cache = database.cache.borrow_mut();
for (addr, _) in &matches {
patch_delete_at(&mut cache, table, *addr, del_tx)?;
}
}
for (_, mut row) in matches {
row[set_ix] = set_value.clone();
database.insert_validated(&table_name, row)?;
}
database.maybe_flush()?;
Ok(count)
})
}
pub fn drop_table(&mut self, name: &str) -> Result<()> {
self.ensure_writable()?;
if self.tables.remove(name).is_none() {
return Err(PvError::TableNotFound(name.into()));
}
self.maybe_flush()
}
pub fn row_count(&self, table_name: &str, before: Option<u64>) -> Result<usize> {
let table = self
.tables
.get(table_name)
.ok_or_else(|| PvError::TableNotFound(table_name.into()))?;
let snapshot = Snapshot::as_of(before.unwrap_or_else(|| self.txm.current()));
let mut count = 0usize;
let mut cache = self.cache.borrow_mut();
scan(&mut cache, table, &self.cas, |_, env, _| {
if snapshot.sees(env) {
count += 1;
}
Ok(())
})?;
Ok(count)
}
#[cfg(feature = "enterprise")]
pub fn configure_enterprise(&mut self, config: crate::enterprise::EnterpriseConfig) {
self.enterprise.configure(config);
}
#[cfg(feature = "enterprise")]
pub fn enterprise_config(&self) -> Option<&crate::enterprise::EnterpriseConfig> {
self.enterprise.config()
}
#[cfg(feature = "enterprise")]
pub fn enterprise_status(&self) -> crate::enterprise::EnterpriseStatus {
crate::enterprise::EnterpriseStatus::current(
self.enterprise.config().cloned(),
self.current_tx(),
)
}
#[cfg(feature = "enterprise")]
pub fn set_audit_sink(&mut self, sink: Arc<dyn crate::enterprise::AuditSink>) {
self.enterprise.set_sink(sink);
}
pub fn assert_compliance(&self, metrics: &RuntimeMetrics) -> Result<()> {
self.compliance
.assert_compliance(metrics)
.map_err(PvError::from)
}
pub fn compliance_monitor(&self) -> &ComplianceMonitor {
&self.compliance
}
pub fn set_compliance_monitor(&mut self, monitor: ComplianceMonitor) {
self.compliance = monitor;
}
pub fn run_wasm_scalar(&self, wasm_bytes: &[u8], func: &str, input: &[u8]) -> Result<i32> {
WasmRuntime::new()
.load(wasm_bytes)?
.call_scalar(func, input)
}
pub fn run_wasm_apply(&self, wasm_bytes: &[u8], func: &str, input: &[u8]) -> Result<Vec<u8>> {
WasmRuntime::new()
.load(wasm_bytes)?
.apply_in_place(func, input)
}
pub fn current_tx(&self) -> TxId {
self.txm.current()
}
pub fn is_writable(&self) -> bool {
self.cache.borrow().is_writable()
}
pub fn table_names(&self) -> Vec<String> {
self.tables.keys().cloned().collect()
}
pub fn inspect_stats(&self) -> Result<DatabaseStats> {
let (storage_mode, allocated_pages) = {
let cache = self.cache.borrow();
let mode = match cache.backend() {
Backend::Dev(_) => "development",
Backend::Mem(_) => "memory",
Backend::Prod(_) => "production",
Backend::Remote(_) => "streamed",
};
(mode.to_owned(), cache.backend().page_count())
};
let mut cas_bytes = 0u64;
for id in 0..self.cas.len() as u64 {
cas_bytes = cas_bytes
.checked_add(self.cas.get(id)?.len() as u64)
.ok_or_else(|| PvError::Corruption("CAS byte count overflowed".into()))?;
}
let mut reachable_pages = 0u64;
let mut tables = Vec::with_capacity(self.tables.len());
for (name, table) in &self.tables {
let live_rows = self.count_visible(name, None, None)?;
let usage = {
let mut cache = self.cache.borrow_mut();
table_page_usage(&mut cache, table)?
};
reachable_pages = reachable_pages.saturating_add(usage.pages);
let indexes = table
.indexes
.iter()
.map(|(column, index)| IndexStats {
column: column.clone(),
entries: index.len(),
distinct_keys: index.distinct_keys(),
encoded_bytes: index.encode_binary().len(),
})
.collect();
tables.push(TableStats {
name: name.clone(),
columns: table.columns.clone(),
live_rows,
row_versions: table.row_versions,
pages: usage.pages,
used_page_bytes: usage.used_bytes,
free_page_bytes: usage.free_bytes,
compression: CompressionStats {
codec: if usage.cold_pages == 0 {
"row-slotted".into()
} else if usage.cold_pages == usage.pages {
"columnar-packed".into()
} else {
"row+columnar-packed".into()
},
compressed_pages: usage.cold_pages,
saved_bytes: usage.saved_bytes,
},
indexes,
});
}
let cache = self.cache.borrow();
Ok(DatabaseStats {
format_version: effective_format_version(&self.tables, self.format_version_floor),
current_transaction: self.current_tx(),
storage_mode,
writable: cache.is_writable(),
page_size: PAGE_SIZE,
allocated_pages,
allocated_page_bytes: allocated_pages.saturating_mul(PAGE_SIZE as u64),
orphaned_pages: allocated_pages.saturating_sub(reachable_pages),
buffer_pool: BufferPoolStats {
capacity_pages: cache.capacity(),
resident_pages: cache.resident(),
},
cas: CasStats {
blobs: self.cas.len(),
stored_bytes: cas_bytes,
},
tables,
})
}
pub fn compact_step(&mut self, max_pages: usize) -> Result<CompactionReport> {
if !self.cache.borrow().is_writable() {
return Err(PvError::ReadOnly);
}
if self.in_transaction() {
return Err(PvError::Transaction(
"cold-page compaction cannot run inside an active transaction".into(),
));
}
let empty = CompactionReport {
examined_pages: 0,
compacted_pages: 0,
skipped_pages: 0,
input_bytes: 0,
encoded_bytes: 0,
saved_bytes: 0,
};
if max_pages == 0 {
return Ok(empty);
}
self.transaction(|database| database.compact_step_transaction(max_pages))
}
fn compact_step_transaction(&mut self, max_pages: usize) -> Result<CompactionReport> {
self.synced.set(false);
let mut report = CompactionReport {
examined_pages: 0,
compacted_pages: 0,
skipped_pages: 0,
input_bytes: 0,
encoded_bytes: 0,
saved_bytes: 0,
};
if self.format_version_floor < FORMAT_VERSION_COLUMNAR {
self.format_version_floor = FORMAT_VERSION_COLUMNAR;
}
let names = self.table_names();
let mut visited_pages = 0usize;
for name in names {
if visited_pages >= max_pages {
break;
}
let (first_page, cursor, tail_id) = {
let table = self.tables.get(&name).expect("catalog name exists");
(table.first_page, table.compaction_cursor, table.tail_id)
};
{
let table = self.tables.get(&name).expect("catalog name exists");
ensure_table_page_ids(&mut self.cache.borrow_mut(), table)?;
}
let mut next = cursor.or(first_page);
let max_hops = self.cache.borrow().backend().page_count().saturating_add(1);
let mut hops = 0u64;
while let Some(page_id) = next {
hops += 1;
if hops > max_hops {
return Err(PvError::Corruption(
"page chain longer than total page count (cycle?)".into(),
));
}
if Some(page_id) == tail_id || visited_pages >= max_pages {
break;
}
visited_pages += 1;
enum Candidate {
AlreadyCold(Option<PageId>),
Row {
next: Option<PageId>,
used: u64,
replacement: Option<(Box<[u8; PAGE_SIZE]>, usize)>,
},
}
let candidate = {
let table = self.tables.get(&name).expect("catalog name exists");
let mut cache = self.cache.borrow_mut();
cache.with_page(page_id, |bytes| match PageType::try_from(bytes[8])? {
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
Ok(Candidate::AlreadyCold(ColdPage::next_page(bytes)?))
}
PageType::Row => {
let page = RowPageRef::new(bytes)?;
let next = page.next_page();
let (_, used, _) = row_page_usage(bytes)?;
let mut records = Vec::with_capacity(page.slot_count() as usize);
for slot in 0..page.slot_count() {
let (envelope, row) = decode_record(page.record(slot)?, &self.cas)?;
if row.len() != table.columns.len() {
return Err(PvError::Corruption(
"record field count does not match table columns".into(),
));
}
records.push((envelope, row));
}
let replacement = match ColdPage::from_records(
page_id,
next,
used as u32,
&records,
) {
Ok((page, encoded)) if encoded < used as usize => {
Some((page, encoded))
}
Ok(_) | Err(PvError::PageFull { .. }) => None,
Err(error) => return Err(error),
};
Ok(Candidate::Row {
next,
used,
replacement,
})
}
})?
};
let following = match &candidate {
Candidate::AlreadyCold(next) | Candidate::Row { next, .. } => *next,
};
if following.is_none() {
return Err(PvError::Corruption(format!(
"table `{name}` page chain ended before its declared tail"
)));
}
match candidate {
Candidate::AlreadyCold(following) => {
self.tables
.get_mut(&name)
.expect("catalog name exists")
.compaction_cursor = following;
next = following;
}
Candidate::Row {
next: following,
used,
replacement: Some((page, encoded)),
} => {
report.examined_pages += 1;
self.cache.borrow_mut().write(page_id, page)?;
let table = self.tables.get_mut(&name).expect("catalog name exists");
table.cold_pages += 1;
table.compaction_cursor = following;
report.compacted_pages += 1;
report.input_bytes = report.input_bytes.saturating_add(used);
report.encoded_bytes = report.encoded_bytes.saturating_add(encoded as u64);
report.saved_bytes = report
.saved_bytes
.saturating_add(used.saturating_sub(encoded as u64));
next = following;
}
Candidate::Row {
next: following,
replacement: None,
..
} => {
report.examined_pages += 1;
report.skipped_pages += 1;
self.tables
.get_mut(&name)
.expect("catalog name exists")
.compaction_cursor = following;
next = following;
}
}
}
}
Ok(report)
}
pub fn upgrade_format_to_latest(&mut self) -> (u16, u16) {
self.synced.set(false);
let before = effective_format_version(&self.tables, self.format_version_floor);
self.format_version_floor = FORMAT_VERSION;
(before, FORMAT_VERSION)
}
pub fn verification_hash(&self) -> Result<String> {
let mut hasher = blake3::Hasher::new();
hasher.update(b"picovolt-verification-v1\0");
hasher.update(&self.current_tx().to_le_bytes());
for (name, table) in &self.tables {
hash_len_prefixed(&mut hasher, name.as_bytes());
hash_len_prefixed(&mut hasher, &serde_json::to_vec(&table.columns)?);
hash_len_prefixed(&mut hasher, &serde_json::to_vec(&table.unique_columns)?);
hash_len_prefixed(&mut hasher, &serde_json::to_vec(&table.not_null_columns)?);
hash_len_prefixed(&mut hasher, &serde_json::to_vec(&table.defaults)?);
hash_len_prefixed(&mut hasher, &serde_json::to_vec(&table.checks)?);
let mut cache = self.cache.borrow_mut();
scan(&mut cache, table, &self.cas, |_address, envelope, row| {
hasher.update(&envelope.encode());
hash_len_prefixed(&mut hasher, &serde_json::to_vec(row)?);
Ok(())
})?;
for (column, index) in &table.indexes {
hash_len_prefixed(&mut hasher, column.as_bytes());
hash_len_prefixed(&mut hasher, &index.encode_binary());
}
}
Ok(hasher.finalize().to_hex().to_string())
}
pub fn set_autocommit(&mut self, on: bool) {
self.autocommit = on;
}
pub fn set_durability(&mut self, durability: Durability) {
self.durability = durability;
}
pub fn durability(&self) -> Durability {
self.durability
}
pub fn set_cache_capacity(&self, pages: usize) -> Result<()> {
self.cache.borrow_mut().set_capacity(pages)
}
pub fn cache_resident(&self) -> usize {
self.cache.borrow().resident()
}
pub fn flush_now(&mut self) -> Result<()> {
self.flush()
}
fn ensure_writable(&self) -> Result<()> {
if self.commit_log.is_some() && !self.in_transaction() {
return Err(PvError::Transaction("low-level mutations on a logged workspace require an explicit transaction; SQL queries are atomic automatically".into()));
}
if self.cache.borrow().is_writable() {
self.synced.set(false);
Ok(())
} else {
Err(PvError::ReadOnly)
}
}
fn maybe_flush(&mut self) -> Result<()> {
if self.autocommit {
self.flush()
} else {
Ok(())
}
}
fn flush(&mut self) -> Result<()> {
if !self.cache.borrow().is_writable() {
return Ok(()); }
let durable = self.durability == Durability::Sync && self.root.is_some();
{
let mut cache = self.cache.borrow_mut();
for table in self.tables.values() {
if let (Some(id), Some(tail)) = (table.tail_id, &table.tail) {
cache.write(id, Box::new(*tail.as_bytes()))?;
}
}
cache.flush()?;
if durable {
cache.sync()?;
}
}
let Some(root) = self.root.clone() else {
return Ok(());
};
let plan = if self.commit_log.is_some() {
IndexPlan::Definitions
} else {
IndexPlan::Json
};
let manifest = self.build_manifest(false, &plan)?;
let json = serde_json::to_vec(&manifest)?;
if self.durability == Durability::Sync {
self.write_manifest_atomic(&root, &json)?;
self.synced.set(true);
Ok(())
} else {
self.synced.set(false);
self.write_manifest_fast(&root, &json)
}
}
fn write_manifest_fast(&self, root: &Path, json: &[u8]) -> Result<()> {
let mut slot = self.manifest_file.borrow_mut();
if slot.is_none() {
*slot = Some(
OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(root.join(MANIFEST_FILE))?,
);
}
let file = slot.as_mut().expect("manifest handle present");
file.seek(SeekFrom::Start(0))?;
file.write_all(json)?;
file.set_len(json.len() as u64)?;
Ok(())
}
fn write_manifest_atomic(&self, root: &Path, json: &[u8]) -> Result<()> {
*self.manifest_file.borrow_mut() = None;
let tmp = root.join("pv_manifest.json.tmp");
{
let mut file = File::create(&tmp)?;
file.write_all(json)?;
file.sync_all()?;
}
fs::rename(&tmp, root.join(MANIFEST_FILE))?;
Ok(())
}
fn build_manifest(&self, include_cas_dir: bool, plan: &IndexPlan) -> Result<Manifest> {
let mut cas_hashes = Vec::with_capacity(self.cas.len());
for id in 0..self.cas.len() as u64 {
cas_hashes.push(self.cas.hash_hex(id)?);
}
let cas_dir = if include_cas_dir {
self.cas.pack()?.1
} else {
Vec::new()
};
let tables = self
.tables
.iter()
.map(|(name, t)| {
let (indexes, binary_indexes) = match plan {
IndexPlan::Definitions => (Vec::new(), Vec::new()),
IndexPlan::Json => (
t.indexes
.iter()
.map(|(col, idx)| PersistedIndex {
column: col.clone(),
pairs: idx.to_pairs(),
})
.collect(),
Vec::new(),
),
IndexPlan::Binary { descs, .. } => (
Vec::new(),
descs
.iter()
.find(|(n, _)| n == name)
.map(|(_, d)| d.clone())
.unwrap_or_default(),
),
};
TableMeta {
name: name.clone(),
columns: t.columns.clone(),
unique_columns: t.unique_columns.iter().cloned().collect(),
not_null_columns: t.not_null_columns.iter().cloned().collect(),
defaults: t.defaults.clone(),
checks: t.checks.clone(),
first_page: t.first_page,
tail_id: t.tail_id,
row_versions: t.row_versions,
cold_pages: t.cold_pages,
compaction_cursor: t.compaction_cursor,
indexed_columns: t.indexes.keys().cloned().collect(),
indexes,
binary_indexes,
}
})
.collect();
let page_count = self.cache.borrow().backend().page_count();
let has_legacy_constraints = self
.tables
.values()
.any(|table| !table.unique_columns.is_empty() || !table.not_null_columns.is_empty());
let has_schema_constraints = self
.tables
.values()
.any(|table| !table.defaults.is_empty() || !table.checks.is_empty());
let has_cold_pages = self.tables.values().any(|table| table.cold_pages > 0);
let mut schema_version = if has_schema_constraints {
FORMAT_VERSION_SCHEMA
} else if has_legacy_constraints {
FORMAT_VERSION_CONSTRAINTS
} else {
FORMAT_VERSION_BASE
};
if has_cold_pages {
schema_version = schema_version.max(FORMAT_VERSION_COLUMNAR);
}
schema_version = schema_version.max(self.format_version_floor);
let (format_version, index_region) = match plan {
IndexPlan::Json | IndexPlan::Definitions => (schema_version, None),
IndexPlan::Binary { offset, len, .. } if *len > 0 => (
schema_version.max(FORMAT_VERSION_INDEX),
Some((*offset, *len)),
),
IndexPlan::Binary { .. } => (schema_version, None),
};
Ok(Manifest {
format_version,
clock: self.txm.current(),
commit_sequence: if matches!(plan, IndexPlan::Definitions) {
match self.cache.borrow().backend() {
Backend::Dev(dev) => Some(match dev.journal_sequence() {
Some(sequence) => sequence,
None => crate::journal::head(
self.root.as_ref().expect("development workspace"),
)?,
}),
_ => None,
}
} else {
None
},
page_count,
tables,
cas_hashes,
cas_dir,
index_region,
})
}
}
enum IndexPlan {
Definitions,
Json,
Binary {
descs: Vec<(String, Vec<BinIndexDesc>)>,
offset: u64,
len: u64,
},
}
struct ResumeWriter {
file: File,
position: u64,
existing: u64,
}
impl Write for ResumeWriter {
fn write(&mut self, bytes: &[u8]) -> std::io::Result<usize> {
let reuse = self
.existing
.saturating_sub(self.position)
.min(bytes.len() as u64) as usize;
if reuse > 0 {
let mut old = [0; 64 * 1024];
for chunk in bytes[..reuse].chunks(old.len()) {
self.file.read_exact(&mut old[..chunk.len()])?;
if old[..chunk.len()] != *chunk {
return Err(std::io::Error::new(std::io::ErrorKind::InvalidData, "bake partial does not match source; keep the source unchanged or choose a new output path"));
}
}
}
self.file.write_all(&bytes[reuse..])?;
self.position += bytes.len() as u64;
Ok(bytes.len())
}
fn flush(&mut self) -> std::io::Result<()> {
self.file.flush()
}
}
pub fn pv_open_dev(path: impl AsRef<Path>) -> Result<Database> {
Database::open_dev(path)
}
pub fn pv_open_prod(path: impl AsRef<Path>) -> Result<Database> {
Database::open_prod(path)
}
fn prepare_workspace_transaction(root: &Path) -> Result<()> {
let marker = root.join(TRANSACTION_MARKER_FILE);
let marker_tmp = root.join(".pv_transaction_active.tmp");
let backup = root.join(TRANSACTION_BACKUP_DIR);
if marker.exists() {
return Err(PvError::Transaction(
"workspace already has an active recovery marker".into(),
));
}
if backup.exists() {
fs::remove_dir_all(&backup)?;
}
if marker_tmp.exists() {
fs::remove_file(&marker_tmp)?;
}
fs::create_dir(&backup)?;
for name in [MANIFEST_FILE, "chunks", "blobs"] {
let source = root.join(name);
if source.exists() {
copy_tree_synced(&source, &backup.join(name))?;
}
}
sync_directory(&backup)?;
{
let mut file = File::create(&marker_tmp)?;
file.write_all(b"PVTX1\n")?;
file.sync_all()?;
}
fs::rename(&marker_tmp, &marker)?;
sync_directory(root)?;
Ok(())
}
fn abort_workspace_transaction_preparation(root: &Path) -> Result<()> {
for path in [
root.join(TRANSACTION_MARKER_FILE),
root.join(".pv_transaction_active.tmp"),
] {
match fs::remove_file(path) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => return Err(error.into()),
}
}
match fs::remove_dir_all(root.join(TRANSACTION_BACKUP_DIR)) {
Ok(()) => {}
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
Err(error) => return Err(error.into()),
}
sync_directory(root)
}
#[cfg(not(target_arch = "wasm32"))]
struct TransactionLock(File);
#[cfg(target_arch = "wasm32")]
type TransactionLock = File;
#[cfg(not(target_arch = "wasm32"))]
impl Drop for TransactionLock {
fn drop(&mut self) {
let _ = FileExt::unlock(&self.0);
}
}
#[cfg(not(target_arch = "wasm32"))]
fn acquire_transaction_lock(root: &Path) -> Result<TransactionLock> {
let lock = OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(root.join(TRANSACTION_LOCK_FILE))?;
lock.try_lock_exclusive().map_err(|error| {
PvError::Transaction(format!(
"workspace transaction is active in another handle or process: {error}"
))
})?;
Ok(TransactionLock(lock))
}
#[cfg(target_arch = "wasm32")]
fn acquire_transaction_lock(root: &Path) -> Result<TransactionLock> {
Ok(OpenOptions::new()
.read(true)
.write(true)
.create(true)
.truncate(false)
.open(root.join(TRANSACTION_LOCK_FILE))?)
}
fn commit_workspace_transaction(root: &Path) -> Result<()> {
let marker = root.join(TRANSACTION_MARKER_FILE);
if !marker.exists() {
return Err(PvError::Transaction(
"filesystem transaction recovery marker is missing".into(),
));
}
fs::remove_file(marker)?;
sync_directory(root).map_err(|error| {
PvError::TransactionOutcomeUnknown(format!(
"transaction marker was removed, but syncing the commit point failed ({error})"
))
})
}
fn recover_workspace_transaction(root: &Path) -> Result<()> {
let marker = root.join(TRANSACTION_MARKER_FILE);
let marker_tmp = root.join(".pv_transaction_active.tmp");
let backup = root.join(TRANSACTION_BACKUP_DIR);
if marker.exists() {
if !backup.join(MANIFEST_FILE).is_file() {
return Err(PvError::Transaction(
"active transaction has no valid recovery manifest".into(),
));
}
restore_workspace_transaction(root)?;
} else if backup.exists() {
fs::remove_dir_all(&backup)?;
}
if marker_tmp.exists() {
fs::remove_file(marker_tmp)?;
}
Ok(())
}
fn restore_workspace_transaction(root: &Path) -> Result<()> {
let marker = root.join(TRANSACTION_MARKER_FILE);
let backup = root.join(TRANSACTION_BACKUP_DIR);
if !marker.exists() || !backup.join(MANIFEST_FILE).is_file() {
return Err(PvError::Transaction(
"workspace transaction recovery files are incomplete".into(),
));
}
for name in [MANIFEST_FILE, "chunks", "blobs"] {
let saved = backup.join(name);
if saved.exists() {
validate_copy_tree(&saved)?;
}
}
for name in [MANIFEST_FILE, "chunks", "blobs"] {
let live = root.join(name);
if let Ok(metadata) = fs::symlink_metadata(&live) {
if metadata.file_type().is_symlink() {
return Err(PvError::Transaction(format!(
"refusing to replace symlink during transaction recovery: {}",
live.display()
)));
}
if metadata.is_dir() {
fs::remove_dir_all(&live)?;
} else {
fs::remove_file(&live)?;
}
}
let saved = backup.join(name);
if saved.exists() {
copy_tree_synced(&saved, &live)?;
}
}
sync_directory(root)?;
fs::remove_file(&marker)?;
sync_directory(root)?;
fs::remove_dir_all(backup)?;
Ok(())
}
fn validate_copy_tree(path: &Path) -> Result<()> {
let metadata = fs::symlink_metadata(path)?;
if metadata.file_type().is_symlink() {
return Err(PvError::Transaction(format!(
"refusing to copy symlink in workspace transaction: {}",
path.display()
)));
}
if metadata.is_file() {
return Ok(());
}
if !metadata.is_dir() {
return Err(PvError::Transaction(format!(
"unsupported workspace entry during transaction: {}",
path.display()
)));
}
for entry in fs::read_dir(path)? {
validate_copy_tree(&entry?.path())?;
}
Ok(())
}
fn copy_tree_synced(source: &Path, destination: &Path) -> Result<()> {
let metadata = fs::symlink_metadata(source)?;
if metadata.file_type().is_symlink() {
return Err(PvError::Transaction(format!(
"refusing to copy symlink in workspace transaction: {}",
source.display()
)));
}
if metadata.is_file() {
if let Some(parent) = destination.parent() {
fs::create_dir_all(parent)?;
}
fs::copy(source, destination)?;
OpenOptions::new()
.read(true)
.write(true)
.open(destination)?
.sync_all()?;
return Ok(());
}
if !metadata.is_dir() {
return Err(PvError::Transaction(format!(
"unsupported workspace entry during transaction: {}",
source.display()
)));
}
fs::create_dir_all(destination)?;
for entry in fs::read_dir(source)? {
let entry = entry?;
copy_tree_synced(&entry.path(), &destination.join(entry.file_name()))?;
}
sync_directory(destination)
}
#[cfg(unix)]
fn sync_directory(path: &Path) -> Result<()> {
File::open(path)?.sync_all()?;
Ok(())
}
#[cfg(not(unix))]
fn sync_directory(_path: &Path) -> Result<()> {
Ok(())
}
pub fn pv_bake(workspace: impl AsRef<Path>, out_path: impl AsRef<Path>) -> Result<()> {
Database::open_dev(workspace)?.bake(out_path)
}
fn project_select(
columns: Vec<String>,
mut rows: Vec<Row>,
projection: Projection,
order: &[OrderBy],
distinct: bool,
limit: Option<usize>,
offset: usize,
) -> Result<QueryResult> {
match limit.map(|k| k.saturating_add(offset)) {
Some(k) if !distinct && !order.is_empty() => {
rows = take_top_n(rows, &columns, order, k)?;
}
_ => sort_rows(&mut rows, &columns, order)?,
}
let (out_columns, mut out_rows) = match projection {
Projection::All => (columns, rows),
Projection::Columns(cols) => {
let idxs = cols
.iter()
.map(|c| projection_col_pos(&columns, c))
.collect::<Result<Vec<_>>>()?;
let projected = rows
.into_iter()
.map(|r| idxs.iter().map(|&i| r[i].clone()).collect())
.collect();
(cols, projected)
}
Projection::Items(items) => {
if items
.iter()
.any(|item| matches!(item.expr, SelectExpr::Aggregate(_)))
{
return Err(PvError::Query(
"aggregate projection requires the grouped execution path".into(),
));
}
let names = items
.iter()
.map(|item| {
item.alias.clone().unwrap_or_else(|| match &item.expr {
SelectExpr::Column(column) => column.clone(),
SelectExpr::Scalar(expr) => scalar_label(expr),
SelectExpr::Aggregate(_) => unreachable!("rejected above"),
})
})
.collect();
let projected = rows
.into_iter()
.map(|row| {
items
.iter()
.map(|item| match &item.expr {
SelectExpr::Column(column) => {
Ok(row[projection_col_pos(&columns, column)?].clone())
}
SelectExpr::Scalar(expr) => eval_scalar(expr, &columns, &row),
SelectExpr::Aggregate(_) => unreachable!("rejected above"),
})
.collect::<Result<Row>>()
})
.collect::<Result<Vec<_>>>()?;
(names, projected)
}
};
if distinct {
dedup_rows(&mut out_rows);
}
if offset > 0 {
out_rows = out_rows.into_iter().skip(offset).collect();
}
if let Some(n) = limit {
out_rows.truncate(n);
}
Ok(QueryResult::Rows {
columns: out_columns,
rows: out_rows,
})
}
fn projection_col_pos(columns: &[String], name: &str) -> Result<usize> {
match column_matches(columns, name).as_slice() {
[] => Err(PvError::Schema(format!("no column `{name}`"))),
[ix] => Ok(*ix),
_ => Err(PvError::Schema(format!("ambiguous column `{name}`"))),
}
}
fn column_matches(columns: &[String], name: &str) -> Vec<usize> {
let exact: Vec<usize> = columns
.iter()
.enumerate()
.filter_map(|(index, column)| (column == name).then_some(index))
.collect();
if !exact.is_empty() || name.contains('.') {
return exact;
}
let suffix = format!(".{name}");
columns
.iter()
.enumerate()
.filter_map(|(index, column)| column.ends_with(&suffix).then_some(index))
.collect()
}
fn resolve_join_keys(
left_columns: &[String],
right_columns: &[String],
first: &str,
second: &str,
) -> Result<(usize, usize)> {
let first_left = column_matches(left_columns, first);
let first_right = column_matches(right_columns, first);
let second_left = column_matches(left_columns, second);
let second_right = column_matches(right_columns, second);
if first_left.len() == 1 && second_right.len() == 1 {
return Ok((first_left[0], second_right[0]));
}
if second_left.len() == 1 && first_right.len() == 1 {
return Ok((second_left[0], first_right[0]));
}
for (reference, matches) in [
(first, &first_left),
(first, &first_right),
(second, &second_left),
(second, &second_right),
] {
if matches.len() > 1 {
return Err(PvError::Schema(format!(
"ambiguous join column `{reference}`"
)));
}
}
Err(PvError::Schema(format!(
"JOIN ON must compare one column from the joined relation with one earlier column; could not resolve `{first} = {second}`"
)))
}
fn order_keys(columns: &[String], order: &[OrderBy]) -> Result<Vec<(usize, bool)>> {
order
.iter()
.map(|ob| projection_col_pos(columns, &ob.column).map(|ix| (ix, ob.descending)))
.collect()
}
fn cmp_by_keys(a: &Row, b: &Row, keys: &[(usize, bool)]) -> std::cmp::Ordering {
for &(ix, descending) in keys {
let ord = cmp_values(&a[ix], &b[ix]);
let ord = if descending { ord.reverse() } else { ord };
if ord != std::cmp::Ordering::Equal {
return ord;
}
}
std::cmp::Ordering::Equal
}
fn take_top_n(rows: Vec<Row>, columns: &[String], order: &[OrderBy], k: usize) -> Result<Vec<Row>> {
if order.is_empty() {
let mut rows = rows;
rows.truncate(k);
return Ok(rows);
}
if k >= rows.len() {
let mut rows = rows;
sort_rows(&mut rows, columns, order)?;
return Ok(rows);
}
let keys = order_keys(columns, order)?;
let mut idx: Vec<usize> = (0..rows.len()).collect();
idx.select_nth_unstable_by(k, |&a, &b| cmp_by_keys(&rows[a], &rows[b], &keys));
idx.truncate(k);
idx.sort_by(|&a, &b| cmp_by_keys(&rows[a], &rows[b], &keys));
Ok(idx.into_iter().map(|i| rows[i].clone()).collect())
}
fn sort_rows(rows: &mut [Row], columns: &[String], order: &[OrderBy]) -> Result<()> {
if order.is_empty() {
return Ok(());
}
let keys = order_keys(columns, order)?;
rows.sort_by(|a, b| cmp_by_keys(a, b, &keys));
Ok(())
}
fn dedup_rows(rows: &mut Vec<Row>) {
let mut seen = std::collections::BTreeSet::new();
rows.retain(|r| seen.insert(r.clone()));
}
fn projection_has_aggregate(projection: &Projection) -> bool {
matches!(
projection,
Projection::Items(items) if items.iter().any(|i| matches!(i.expr, SelectExpr::Aggregate(_)))
)
}
fn count_star_only(projection: &Projection) -> Option<Option<String>> {
if let Projection::Items(items) = projection {
if items.len() == 1 {
if let SelectExpr::Aggregate(Aggregate {
func: AggFunc::Count,
column: None,
}) = &items[0].expr
{
return Some(items[0].alias.clone());
}
}
}
None
}
fn cmp_values(a: &Value, b: &Value) -> std::cmp::Ordering {
a.cmp(b)
}
fn source_predicate(pred: &Predicate, qualifier: &str) -> Option<Predicate> {
let column = |name: &str| {
name.strip_prefix(qualifier)?
.strip_prefix('.')
.map(str::to_owned)
};
Some(match pred {
Predicate::Compare {
column: name,
op,
value,
} => Predicate::Compare {
column: column(name)?,
op: *op,
value: value.clone(),
},
Predicate::In {
column: name,
values,
negated,
} => Predicate::In {
column: column(name)?,
values: values.clone(),
negated: *negated,
},
Predicate::Between {
column: name,
low,
high,
negated,
} => Predicate::Between {
column: column(name)?,
low: low.clone(),
high: high.clone(),
negated: *negated,
},
Predicate::IsNull {
column: name,
negated,
} => Predicate::IsNull {
column: column(name)?,
negated: *negated,
},
Predicate::And(a, b) => match (
source_predicate(a, qualifier),
source_predicate(b, qualifier),
) {
(Some(a), Some(b)) => Predicate::And(Box::new(a), Box::new(b)),
(Some(a), None) => a,
(None, Some(b)) => b,
_ => return None,
},
Predicate::Or(a, b) => Predicate::Or(
Box::new(source_predicate(a, qualifier)?),
Box::new(source_predicate(b, qualifier)?),
),
})
}
type IndexRange = (std::ops::Bound<Value>, std::ops::Bound<Value>);
fn intersect_range(a: &IndexRange, b: &IndexRange) -> Option<IndexRange> {
use std::ops::Bound::{Excluded, Included, Unbounded};
fn lower(a: &std::ops::Bound<Value>, b: &std::ops::Bound<Value>) -> std::ops::Bound<Value> {
match (a, b) {
(Unbounded, _) => b.clone(),
(_, Unbounded) => a.clone(),
(Included(x) | Excluded(x), Included(y) | Excluded(y)) => {
if x > y {
a.clone()
} else if y > x {
b.clone()
} else if matches!(a, Excluded(_)) {
a.clone()
} else {
b.clone()
}
}
}
}
fn upper(a: &std::ops::Bound<Value>, b: &std::ops::Bound<Value>) -> std::ops::Bound<Value> {
match (a, b) {
(Unbounded, _) => b.clone(),
(_, Unbounded) => a.clone(),
(Included(x) | Excluded(x), Included(y) | Excluded(y)) => {
if x < y {
a.clone()
} else if y < x {
b.clone()
} else if matches!(a, Excluded(_)) {
a.clone()
} else {
b.clone()
}
}
}
}
let result = (lower(&a.0, &b.0), upper(&a.1, &b.1));
match (&result.0, &result.1) {
(Included(x) | Excluded(x), Included(y) | Excluded(y))
if x > y
|| (x == y
&& (matches!(result.0, Excluded(_)) || matches!(result.1, Excluded(_)))) =>
{
None
}
_ => Some(result),
}
}
fn comparison_ranges(op: CompareOp, value: &Value) -> Option<Vec<IndexRange>> {
use std::ops::Bound::{Excluded, Included, Unbounded};
let raw = |v: Value| match op {
CompareOp::Eq => Some((Included(v.clone()), Included(v))),
CompareOp::Lt => Some((Unbounded, Excluded(v))),
CompareOp::Le => Some((Unbounded, Included(v))),
CompareOp::Gt => Some((Excluded(v), Unbounded)),
CompareOp::Ge => Some((Included(v), Unbounded)),
_ => None,
};
if matches!(value, Value::Null) {
return raw(Value::Null).map(|_| Vec::new());
}
let numeric = match value {
Value::Int(n) => Some(promote_int(*n)),
Value::Decimal(n) => Some(*n),
_ => None,
};
let Some(n) = numeric else {
return raw(value.clone()).map(|r| {
intersect_range(&r, &(Excluded(Value::Null), Unbounded))
.into_iter()
.collect()
});
};
raw(value.clone())?;
let mut result = Vec::new();
let floor = n.div_euclid(DECIMAL_DEN);
let remainder = n.rem_euclid(DECIMAL_DEN);
let min = i64::MIN as i128;
let max = i64::MAX as i128;
let integers = match op {
CompareOp::Eq if remainder == 0 && floor >= min && floor <= max => Some((floor, floor)),
CompareOp::Eq => None,
CompareOp::Lt => Some((min, floor - i128::from(remainder == 0))),
CompareOp::Le => Some((min, floor)),
CompareOp::Gt => Some((floor + 1, max)),
CompareOp::Ge => Some((floor + i128::from(remainder != 0), max)),
_ => None,
};
if let Some((lo, hi)) = integers {
let (lo, hi) = (lo.max(min), hi.min(max));
if lo <= hi {
result.push((
Included(Value::Int(lo as i64)),
Included(Value::Int(hi as i64)),
));
}
}
if let Some(range) = intersect_range(
&raw(Value::Decimal(n))?,
&(
Included(Value::Decimal(i128::MIN)),
Included(Value::Decimal(i128::MAX)),
),
) {
result.push(range);
}
if matches!(op, CompareOp::Gt | CompareOp::Ge) {
result.push((Excluded(Value::Decimal(i128::MAX)), Unbounded));
}
Some(result)
}
fn index_candidates(
table: &Table,
pred: &Predicate,
mut budget: Option<&mut QueryBudget>,
) -> Result<Option<Vec<RecordAddr>>> {
fn collect<'a>(pred: &'a Predicate, out: &mut Vec<(&'a str, Vec<IndexRange>)>) {
match pred {
Predicate::And(a, b) => {
collect(a, out);
collect(b, out);
}
Predicate::Compare { column, op, value } => {
if let Some(ranges) = comparison_ranges(*op, value) {
out.push((column, ranges));
}
}
Predicate::Between {
column,
low,
high,
negated: false,
} => {
if let (Some(lo), Some(hi)) = (
comparison_ranges(CompareOp::Ge, low),
comparison_ranges(CompareOp::Le, high),
) {
let ranges = lo
.iter()
.flat_map(|a| hi.iter().filter_map(|b| intersect_range(a, b)))
.collect();
out.push((column, ranges));
}
}
_ => {}
}
}
if let Predicate::Compare {
column,
op: CompareOp::Eq,
value,
} = pred
{
if let Some(index) = table.indexes.get(column) {
return Ok(Some(index_equality_candidates(index, value, budget)?));
}
}
let mut conjuncts = Vec::new();
collect(pred, &mut conjuncts);
let mut by_column: BTreeMap<&str, Vec<IndexRange>> = BTreeMap::new();
for (column, ranges) in conjuncts {
if !table.indexes.contains_key(column) {
continue;
}
if let Some(existing) = by_column.get_mut(column) {
*existing = existing
.iter()
.flat_map(|a| ranges.iter().filter_map(|b| intersect_range(a, b)))
.collect();
} else {
by_column.insert(column, ranges);
}
}
let mut best = None;
for (column, ranges) in by_column {
if let Some(budget) = budget.as_deref_mut() {
budget.checkpoint()?;
}
let index = &table.indexes[column];
let count: usize = ranges.iter().map(|r| index.range_len(r.clone())).sum();
if best.as_ref().is_none_or(|(_, _, old)| count < *old) {
best = Some((index, ranges, count));
}
}
let Some((index, ranges, count)) = best else {
return Ok(None);
};
if let Some(budget) = budget {
budget.reserve_index_candidates(count)?;
}
let mut result = Vec::with_capacity(count);
for range in ranges {
index.append_range(range, &mut result);
}
Ok(Some(result))
}
fn index_equality_candidates(
index: &SecondaryIndex,
value: &Value,
budget: Option<&mut QueryBudget>,
) -> Result<Vec<RecordAddr>> {
let exact = index.lookup(value);
let equivalent = match value {
Value::Int(value) => index.lookup(&Value::Decimal(promote_int(*value))),
Value::Decimal(value) if value % DECIMAL_DEN == 0 => {
if let Ok(integer) = i64::try_from(value / DECIMAL_DEN) {
index.lookup(&Value::Int(integer))
} else {
&[]
}
}
_ => &[],
};
let count = exact
.len()
.checked_add(equivalent.len())
.ok_or_else(|| PvError::ResourceLimit("index candidate count overflowed".into()))?;
if let Some(budget) = budget {
budget.reserve_index_candidates(count)?;
}
let mut candidates = Vec::with_capacity(count);
candidates.extend_from_slice(exact);
candidates.extend_from_slice(equivalent);
Ok(candidates)
}
fn check_predicate_columns(columns: &[String], pred: &Predicate) -> Result<()> {
match pred {
Predicate::And(a, b) | Predicate::Or(a, b) => {
check_predicate_columns(columns, a)?;
check_predicate_columns(columns, b)
}
Predicate::Compare { column, .. }
| Predicate::In { column, .. }
| Predicate::Between { column, .. }
| Predicate::IsNull { column, .. } => projection_col_pos(columns, column).map(|_| ()),
}
}
fn validate_record_shape(values: &[Value]) -> Result<()> {
let _: u16 = values
.len()
.try_into()
.map_err(|_| PvError::Schema("too many columns (max 65535)".into()))?;
let mut len = RecordEnvelope::ENCODED_LEN + std::mem::size_of::<u16>();
for value in values {
let field_len = match value {
Value::Null => 1,
Value::Int(_) => 1 + std::mem::size_of::<i64>(),
Value::Decimal(_) => 1 + std::mem::size_of::<i128>(),
Value::Text(value) => encoded_bytes_field_len(value.len()),
Value::Blob(value) => encoded_bytes_field_len(value.len()),
};
len = len.saturating_add(field_len);
}
if len > MAX_RECORD {
return Err(PvError::Schema(format!(
"record of {len} bytes exceeds page capacity ({MAX_RECORD})"
)));
}
Ok(())
}
fn encoded_bytes_field_len(len: usize) -> usize {
if CasStore::should_intern(len) {
1 + std::mem::size_of::<u64>()
} else {
1 + std::mem::size_of::<u16>() + len
}
}
fn validate_schema_metadata(
table: &str,
columns: &[String],
unique_columns: &[String],
not_null_columns: &[String],
defaults: &BTreeMap<String, Value>,
checks: &[Predicate],
persisted: bool,
) -> Result<()> {
let invalid = |message: String| {
if persisted {
PvError::Corruption(format!("invalid schema for table `{table}`: {message}"))
} else {
PvError::Schema(format!("invalid schema for table `{table}`: {message}"))
}
};
if columns.is_empty() {
return Err(invalid("at least one column is required".into()));
}
if columns.len() > u16::MAX as usize {
return Err(invalid("too many columns (max 65535)".into()));
}
let mut seen = BTreeSet::new();
for column in columns {
if !seen.insert(column) {
return Err(invalid(format!("duplicate column `{column}`")));
}
}
for (kind, constrained) in [
("UNIQUE/PRIMARY KEY", unique_columns),
("NOT NULL/PRIMARY KEY", not_null_columns),
] {
for column in constrained {
if !seen.contains(column) {
return Err(invalid(format!(
"{kind} references unknown column `{column}`"
)));
}
}
}
for column in defaults.keys() {
if !seen.contains(column) {
return Err(invalid(format!(
"DEFAULT references unknown column `{column}`"
)));
}
}
let mut nodes = 0usize;
for check in checks {
validate_check_shape(check, columns, 1, &mut nodes).map_err(&invalid)?;
}
Ok(())
}
const MAX_CHECK_DEPTH: usize = 32;
const MAX_CHECK_NODES: usize = 256;
fn validate_check_shape(
predicate: &Predicate,
columns: &[String],
depth: usize,
nodes: &mut usize,
) -> std::result::Result<(), String> {
*nodes = nodes.saturating_add(1);
if let Predicate::In { values, .. } = predicate {
*nodes = nodes.saturating_add(values.len());
}
if depth > MAX_CHECK_DEPTH || *nodes > MAX_CHECK_NODES {
return Err(format!(
"CHECK expression exceeds the {MAX_CHECK_DEPTH}-level/{MAX_CHECK_NODES}-node limit"
));
}
match predicate {
Predicate::And(left, right) | Predicate::Or(left, right) => {
validate_check_shape(left, columns, depth + 1, nodes)?;
validate_check_shape(right, columns, depth + 1, nodes)
}
Predicate::Compare { column, .. }
| Predicate::In { column, .. }
| Predicate::Between { column, .. }
| Predicate::IsNull { column, .. } => {
if columns.iter().any(|known| known == column) {
Ok(())
} else {
Err(format!("CHECK references unknown column `{column}`"))
}
}
}
}
fn row_matches(pred: &Predicate, columns: &[String], row: &[Value]) -> Result<bool> {
Ok(check_result(pred, columns, row)?.unwrap_or(false))
}
fn check_result(pred: &Predicate, columns: &[String], row: &[Value]) -> Result<Option<bool>> {
match pred {
Predicate::And(left, right) => {
let left = check_result(left, columns, row)?;
let right = check_result(right, columns, row)?;
Ok(match (left, right) {
(Some(false), _) | (_, Some(false)) => Some(false),
(Some(true), Some(true)) => Some(true),
_ => None,
})
}
Predicate::Or(left, right) => {
let left = check_result(left, columns, row)?;
let right = check_result(right, columns, row)?;
Ok(match (left, right) {
(Some(true), _) | (_, Some(true)) => Some(true),
(Some(false), Some(false)) => Some(false),
_ => None,
})
}
Predicate::Compare { column, op, value } => {
let cell = &row[projection_col_pos(columns, column)?];
if matches!(cell, Value::Null) || matches!(value, Value::Null) {
Ok(None)
} else {
Ok(Some(eval_compare(cell, *op, value)))
}
}
Predicate::In {
column,
values,
negated,
} => {
let cell = &row[projection_col_pos(columns, column)?];
if matches!(cell, Value::Null) {
return Ok(None);
}
let matched = values
.iter()
.filter(|value| !matches!(value, Value::Null))
.any(|value| values_equal(cell, value));
if matched {
Ok(Some(!negated))
} else if values.iter().any(|value| matches!(value, Value::Null)) {
Ok(None)
} else {
Ok(Some(*negated))
}
}
Predicate::Between {
column,
low,
high,
negated,
} => {
let cell = &row[projection_col_pos(columns, column)?];
if matches!(cell, Value::Null)
|| matches!(low, Value::Null)
|| matches!(high, Value::Null)
{
return Ok(None);
}
let in_range = numeric_cmp(cell, low) != std::cmp::Ordering::Less
&& numeric_cmp(cell, high) != std::cmp::Ordering::Greater;
Ok(Some(in_range != *negated))
}
Predicate::IsNull { column, negated } => {
let is_null = matches!(row[projection_col_pos(columns, column)?], Value::Null);
Ok(Some(is_null != *negated))
}
}
}
fn col_pos(columns: &[String], column: &str) -> Result<usize> {
columns
.iter()
.position(|c| c == column)
.ok_or_else(|| PvError::Schema(format!("no column `{column}`")))
}
fn promote_int(i: i64) -> i128 {
(i as i128).saturating_mul(DECIMAL_DEN)
}
fn numeric_cmp(a: &Value, b: &Value) -> std::cmp::Ordering {
match (a, b) {
(Value::Int(x), Value::Decimal(y)) => promote_int(*x).cmp(y),
(Value::Decimal(x), Value::Int(y)) => x.cmp(&promote_int(*y)),
_ => cmp_values(a, b),
}
}
fn values_equal(a: &Value, b: &Value) -> bool {
match (a, b) {
(Value::Int(_), Value::Decimal(_)) | (Value::Decimal(_), Value::Int(_)) => {
numeric_cmp(a, b) == std::cmp::Ordering::Equal
}
_ => a == b,
}
}
fn join_key(value: &Value) -> Value {
match value {
Value::Int(value) => Value::Decimal(promote_int(*value)),
value => value.clone(),
}
}
fn eval_compare(lhs: &Value, op: CompareOp, rhs: &Value) -> bool {
use std::cmp::Ordering;
if matches!(lhs, Value::Null) || matches!(rhs, Value::Null) {
return false;
}
match op {
CompareOp::Eq => values_equal(lhs, rhs),
CompareOp::Ne => !values_equal(lhs, rhs),
CompareOp::Like => match (lhs, rhs) {
(Value::Text(t), Value::Text(p)) => like_match(t, p),
_ => false,
},
CompareOp::NotLike => match (lhs, rhs) {
(Value::Text(t), Value::Text(p)) => !like_match(t, p),
_ => false,
},
CompareOp::Lt | CompareOp::Le | CompareOp::Gt | CompareOp::Ge => {
let ord = numeric_cmp(lhs, rhs);
match op {
CompareOp::Lt => ord == Ordering::Less,
CompareOp::Le => ord != Ordering::Greater,
CompareOp::Gt => ord == Ordering::Greater,
CompareOp::Ge => ord != Ordering::Less,
_ => unreachable!(),
}
}
}
}
fn like_match(text: &str, pattern: &str) -> bool {
let t: Vec<char> = text.chars().collect();
let p: Vec<char> = pattern.chars().collect();
let (mut ti, mut pi) = (0usize, 0usize);
let (mut star_p, mut star_t): (Option<usize>, usize) = (None, 0);
while ti < t.len() {
if pi < p.len() && (p[pi] == '_' || p[pi] == t[ti]) {
ti += 1;
pi += 1;
} else if pi < p.len() && p[pi] == '%' {
star_p = Some(pi);
star_t = ti;
pi += 1;
} else if let Some(sp) = star_p {
pi = sp + 1;
star_t += 1;
ti = star_t;
} else {
return false;
}
}
while pi < p.len() && p[pi] == '%' {
pi += 1;
}
pi == p.len()
}
fn projection_to_items(projection: Projection) -> Result<Vec<SelectItem>> {
match projection {
Projection::Items(items) => Ok(items),
Projection::Columns(cols) => Ok(cols
.into_iter()
.map(|c| SelectItem {
expr: SelectExpr::Column(c),
alias: None,
})
.collect()),
Projection::All => Err(PvError::Query(
"SELECT * cannot be combined with GROUP BY or aggregates".into(),
)),
}
}
fn scalar_label(expr: &ScalarExpr) -> String {
match expr {
ScalarExpr::Column(column) => column.clone(),
ScalarExpr::Literal(value) => value.to_string(),
ScalarExpr::Function {
function,
arguments,
} => {
let name = match function {
ScalarFunc::Lower => "lower",
ScalarFunc::Upper => "upper",
ScalarFunc::Trim => "trim",
ScalarFunc::Length => "length",
ScalarFunc::Abs => "abs",
ScalarFunc::Coalesce => "coalesce",
ScalarFunc::NullIf => "nullif",
};
let arguments = arguments
.iter()
.map(scalar_label)
.collect::<Vec<_>>()
.join(",");
format!("{name}({arguments})")
}
ScalarExpr::Case { .. } => "case".into(),
}
}
fn eval_scalar(expr: &ScalarExpr, columns: &[String], row: &[Value]) -> Result<Value> {
match expr {
ScalarExpr::Column(column) => Ok(row[projection_col_pos(columns, column)?].clone()),
ScalarExpr::Literal(value) => Ok(value.clone()),
ScalarExpr::Case {
branches,
else_expr,
} => {
for (predicate, value) in branches {
if row_matches(predicate, columns, row)? {
return eval_scalar(value, columns, row);
}
}
match else_expr {
Some(value) => eval_scalar(value, columns, row),
None => Ok(Value::Null),
}
}
ScalarExpr::Function {
function,
arguments,
} => {
if *function == ScalarFunc::Coalesce {
for argument in arguments {
let value = eval_scalar(argument, columns, row)?;
if !matches!(value, Value::Null) {
return Ok(value);
}
}
return Ok(Value::Null);
}
let values = arguments
.iter()
.map(|argument| eval_scalar(argument, columns, row))
.collect::<Result<Vec<_>>>()?;
eval_scalar_function(*function, &values)
}
}
}
fn eval_scalar_function(function: ScalarFunc, values: &[Value]) -> Result<Value> {
let type_error = |name: &str, expected: &str, value: &Value| {
PvError::Schema(format!(
"{name} expects {expected}, found {}",
value.type_name()
))
};
match function {
ScalarFunc::Lower | ScalarFunc::Upper | ScalarFunc::Trim => match &values[0] {
Value::Null => Ok(Value::Null),
Value::Text(value) => Ok(Value::Text(match function {
ScalarFunc::Lower => value.to_lowercase(),
ScalarFunc::Upper => value.to_uppercase(),
ScalarFunc::Trim => value.trim().to_owned(),
_ => unreachable!(),
})),
value => Err(type_error("text function", "text", value)),
},
ScalarFunc::Length => match &values[0] {
Value::Null => Ok(Value::Null),
Value::Text(value) => Ok(Value::Int(value.chars().count() as i64)),
Value::Blob(value) => Ok(Value::Int(value.len() as i64)),
value => Err(type_error("LENGTH", "text or blob", value)),
},
ScalarFunc::Abs => match &values[0] {
Value::Null => Ok(Value::Null),
Value::Int(value) => value
.checked_abs()
.map(Value::Int)
.ok_or_else(|| PvError::Schema("ABS overflowed i64".into())),
Value::Decimal(value) => value
.checked_abs()
.map(Value::Decimal)
.ok_or_else(|| PvError::Schema("ABS overflowed decimal".into())),
value => Err(type_error("ABS", "a numeric value", value)),
},
ScalarFunc::Coalesce => unreachable!("COALESCE is evaluated lazily"),
ScalarFunc::NullIf => {
if values_equal(&values[0], &values[1]) {
Ok(Value::Null)
} else {
Ok(values[0].clone())
}
}
}
}
#[allow(clippy::too_many_arguments)] fn project_grouped(
columns: Vec<String>,
rows: Vec<Row>,
items: Vec<SelectItem>,
group_by: Vec<String>,
having: Option<HavingPred>,
order: Vec<OrderBy>,
distinct: bool,
limit: Option<usize>,
offset: usize,
) -> Result<QueryResult> {
let gb_idx: Vec<usize> = group_by
.iter()
.map(|column| projection_col_pos(&columns, column))
.collect::<Result<_>>()?;
for item in &items {
match &item.expr {
SelectExpr::Column(c) => {
let column_index = projection_col_pos(&columns, c)?;
if !gb_idx.contains(&column_index) {
return Err(PvError::Schema(format!(
"column `{c}` must appear in GROUP BY or inside an aggregate"
)));
}
}
SelectExpr::Scalar(_) => {
return Err(PvError::Query(
"scalar expressions cannot yet be mixed with GROUP BY or aggregates".into(),
))
}
SelectExpr::Aggregate(_) => {}
}
}
let mut groups: BTreeMap<Vec<Value>, Vec<Row>> = BTreeMap::new();
if group_by.is_empty() {
groups.insert(Vec::new(), rows);
} else {
for row in rows {
let key: Vec<Value> = gb_idx.iter().map(|&i| row[i].clone()).collect();
groups.entry(key).or_default().push(row);
}
}
let out_columns: Vec<String> = items
.iter()
.map(|it| match (&it.alias, &it.expr) {
(Some(a), _) => a.clone(),
(None, SelectExpr::Column(c)) => c.clone(),
(None, SelectExpr::Aggregate(a)) => agg_label(a),
(None, SelectExpr::Scalar(expr)) => scalar_label(expr),
})
.collect();
let mut out_rows: Vec<Row> = Vec::with_capacity(groups.len());
for (key, group_rows) in &groups {
let mut out = Vec::with_capacity(items.len());
for item in &items {
match &item.expr {
SelectExpr::Column(c) => {
let source_index = projection_col_pos(&columns, c)?;
let gi = gb_idx
.iter()
.position(|&group_index| group_index == source_index)
.expect("validated above");
out.push(key[gi].clone());
}
SelectExpr::Aggregate(a) => {
out.push(compute_one_aggregate(a, &columns, group_rows)?)
}
SelectExpr::Scalar(_) => unreachable!("scalar expressions rejected above"),
}
}
let keep = match &having {
None => true,
Some(h) => eval_having(h, &out_columns, &out, &columns, group_rows)?,
};
if keep {
out_rows.push(out);
}
}
sort_rows(&mut out_rows, &out_columns, &order)?;
if distinct {
dedup_rows(&mut out_rows);
}
if offset > 0 {
out_rows = out_rows.into_iter().skip(offset).collect();
}
if let Some(n) = limit {
out_rows.truncate(n);
}
Ok(QueryResult::Rows {
columns: out_columns,
rows: out_rows,
})
}
fn eval_having(
pred: &HavingPred,
out_columns: &[String],
out_row: &[Value],
columns: &[String],
group_rows: &[Row],
) -> Result<bool> {
match pred {
HavingPred::And(a, b) => Ok(eval_having(a, out_columns, out_row, columns, group_rows)?
&& eval_having(b, out_columns, out_row, columns, group_rows)?),
HavingPred::Or(a, b) => Ok(eval_having(a, out_columns, out_row, columns, group_rows)?
|| eval_having(b, out_columns, out_row, columns, group_rows)?),
HavingPred::Compare { term, op, value } => {
let lhs = match term {
HavingTerm::Column(name) => out_row[projection_col_pos(out_columns, name)?].clone(),
HavingTerm::Aggregate(agg) => compute_one_aggregate(agg, columns, group_rows)?,
};
Ok(eval_compare(&lhs, *op, value))
}
}
}
fn compute_one_aggregate(agg: &Aggregate, columns: &[String], rows: &[Row]) -> Result<Value> {
let col_ix = match &agg.column {
None => None,
Some(c) => Some(projection_col_pos(columns, c)?),
};
let value = match agg.func {
AggFunc::Count => {
let n = match col_ix {
None => rows.len(),
Some(ix) => rows
.iter()
.filter(|r| !matches!(r[ix], Value::Null))
.count(),
};
Value::Int(n as i64)
}
AggFunc::Sum => {
let ix = col_ix.expect("SUM requires a column");
let (int_sum, dec_sum, any_decimal, count) = sum_numeric_column(rows, ix, "SUM")?;
if count == 0 {
Value::Null
} else if any_decimal {
Value::Decimal(combine_mantissa(int_sum, dec_sum)?)
} else {
Value::Int(
i64::try_from(int_sum)
.map_err(|_| PvError::Schema("SUM overflowed i64".into()))?,
)
}
}
AggFunc::Min | AggFunc::Max => {
let ix = col_ix.expect("MIN/MAX requires a column");
let mut acc: Option<&Value> = None;
for r in rows {
if matches!(r[ix], Value::Null) {
continue;
}
acc = Some(match acc {
None => &r[ix],
Some(cur) => {
let take = match agg.func {
AggFunc::Min => numeric_cmp(&r[ix], cur).is_lt(),
AggFunc::Max => numeric_cmp(&r[ix], cur).is_gt(),
_ => unreachable!(),
};
if take {
&r[ix]
} else {
cur
}
}
});
}
acc.cloned().unwrap_or(Value::Null)
}
AggFunc::Avg => {
let ix = col_ix.expect("AVG requires a column");
let (int_sum, dec_sum, _any, count) = sum_numeric_column(rows, ix, "AVG")?;
if count == 0 {
Value::Null
} else {
Value::Decimal(round_div_half_away(
combine_mantissa(int_sum, dec_sum)?,
count,
))
}
}
};
Ok(value)
}
fn round_div_half_away(num: i128, den: i128) -> i128 {
let negative = (num < 0) ^ (den < 0);
let n = num.unsigned_abs();
let d = den.unsigned_abs();
let q = n / d;
let r = n % d;
let q = if r * 2 >= d { q + 1 } else { q };
if negative {
if q == 1u128 << 127 {
i128::MIN
} else {
-(q as i128)
}
} else {
q as i128
}
}
fn sum_numeric_column(rows: &[Row], ix: usize, label: &str) -> Result<(i128, i128, bool, i128)> {
let mut int_sum: i128 = 0;
let mut dec_sum: i128 = 0;
let mut any_decimal = false;
let mut count: i128 = 0;
for r in rows {
match &r[ix] {
Value::Int(i) => {
int_sum = int_sum
.checked_add(*i as i128)
.ok_or_else(|| PvError::Schema(format!("{label} overflowed")))?;
count += 1;
}
Value::Decimal(m) => {
dec_sum = dec_sum
.checked_add(*m)
.ok_or_else(|| PvError::Schema(format!("{label} overflowed")))?;
any_decimal = true;
count += 1;
}
Value::Null => {}
other => {
return Err(PvError::Schema(format!(
"{label} requires numeric values, found {other:?}"
)))
}
}
}
Ok((int_sum, dec_sum, any_decimal, count))
}
fn combine_mantissa(int_sum: i128, dec_sum: i128) -> Result<i128> {
int_sum
.checked_mul(DECIMAL_DEN)
.and_then(|s| s.checked_add(dec_sum))
.ok_or_else(|| PvError::Schema("numeric aggregate overflowed".into()))
}
fn effective_format_version(tables: &BTreeMap<String, Table>, floor: u16) -> u16 {
let mut version = FORMAT_VERSION_BASE.max(floor);
if tables.values().any(|table| !table.indexes.is_empty()) {
version = version.max(FORMAT_VERSION_INDEX);
}
if tables
.values()
.any(|table| !table.unique_columns.is_empty() || !table.not_null_columns.is_empty())
{
version = version.max(FORMAT_VERSION_CONSTRAINTS);
}
if tables
.values()
.any(|table| !table.defaults.is_empty() || !table.checks.is_empty())
{
version = version.max(FORMAT_VERSION_SCHEMA);
}
if tables.values().any(|table| table.cold_pages > 0) {
version = version.max(FORMAT_VERSION_COLUMNAR);
}
version
}
fn hash_len_prefixed(hasher: &mut blake3::Hasher, bytes: &[u8]) {
hasher.update(&(bytes.len() as u64).to_le_bytes());
hasher.update(bytes);
}
#[derive(Default)]
struct TablePageUsage {
pages: u64,
used_bytes: u64,
free_bytes: u64,
cold_pages: u64,
saved_bytes: u64,
}
fn row_page_usage(bytes: &[u8]) -> Result<(Option<PageId>, u64, u64)> {
let page = RowPageRef::new(bytes)?;
let header = page.header();
let slot_bytes = (header.slot_count as usize)
.checked_mul(SLOT_SIZE)
.ok_or_else(|| PvError::Corruption("row-page slot bytes overflowed".into()))?;
let slot_end = PAGE_HEADER_SIZE
.checked_add(slot_bytes)
.ok_or_else(|| PvError::Corruption("row-page slot boundary overflowed".into()))?;
let free_end = header.free_space_ptr as usize;
if free_end > PAGE_SIZE || slot_end > free_end {
return Err(PvError::Corruption(format!(
"row page header out of range: slot_count={}, free_space_ptr={}",
header.slot_count, header.free_space_ptr
)));
}
let free = free_end - slot_end;
let used = PAGE_SIZE - free;
Ok((page.next_page(), used as u64, free as u64))
}
fn page_usage(bytes: &[u8]) -> Result<(Option<PageId>, u64, u64, bool, u64)> {
let page_type = PageType::try_from(*bytes.get(8).ok_or(PvError::BufferTooSmall {
needed: PAGE_HEADER_SIZE,
actual: bytes.len(),
})?)?;
match page_type {
PageType::Row => {
let (next, used, free) = row_page_usage(bytes)?;
Ok((next, used, free, false, 0))
}
PageType::Columnar => {
let next = ColdPage::next_page(bytes)?;
let used = ColdPage::encoded_len(bytes)? as u64;
let original = ColdPage::original_used_bytes(bytes)? as u64;
Ok((
next,
used,
(PAGE_SIZE as u64).saturating_sub(used),
true,
original.saturating_sub(used),
))
}
}
}
fn table_chain_contains_page(cache: &mut PageCache, table: &Table, target: PageId) -> Result<bool> {
ensure_table_page_ids(cache, table)?;
Ok(table
.page_ids
.borrow()
.as_ref()
.expect("ownership set initialized")
.contains(&target))
}
fn ensure_table_page_ids(cache: &mut PageCache, table: &Table) -> Result<()> {
if table.page_ids.borrow().is_some() {
return Ok(());
}
let page_count = cache.backend().page_count();
let max_hops = page_count.saturating_add(1);
let mut hops = 0u64;
let mut next = table.first_page;
let mut ids = BTreeSet::new();
let mut cold_pages = 0u64;
let mut cursor_found = table.compaction_cursor.is_none();
while let Some(page_id) = next {
hops += 1;
if hops > max_hops {
return Err(PvError::Corruption(
"page chain longer than total page count (cycle?)".into(),
));
}
if page_id >= page_count {
return Err(PvError::Corruption(format!(
"table page {page_id} is outside the {page_count}-page backend"
)));
}
if !ids.insert(page_id) {
return Err(PvError::Corruption("cyclic table page chain".into()));
}
if table.compaction_cursor == Some(page_id) {
cursor_found = true;
}
let (following, cold) = if Some(page_id) == table.tail_id {
if let Some(tail) = &table.tail {
(tail.next_page(), false)
} else {
cache.with_page(page_id, page_link_and_kind)?
}
} else {
cache.with_page(page_id, page_link_and_kind)?
};
if cold {
cold_pages += 1;
if cold_pages > table.cold_pages {
return Err(PvError::Corruption(
"page chain contains more cold pages than the manifest declares".into(),
));
}
}
if Some(page_id) == table.tail_id && following.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
next = following;
}
if table.tail_id.is_some_and(|tail| !ids.contains(&tail)) {
return Err(PvError::Corruption(
"table page chain does not reach its declared tail".into(),
));
}
if cold_pages != table.cold_pages {
return Err(PvError::Corruption(format!(
"manifest declares {} cold page(s), page chain contains {cold_pages}",
table.cold_pages
)));
}
if !cursor_found {
return Err(PvError::Corruption(
"table compaction cursor is outside its page chain".into(),
));
}
*table.page_ids.borrow_mut() = Some(ids);
Ok(())
}
fn page_link_and_kind(bytes: &[u8; PAGE_SIZE]) -> Result<(Option<PageId>, bool)> {
match PageType::try_from(bytes[8])? {
PageType::Row => Ok((RowPageRef::new(bytes)?.next_page(), false)),
PageType::Columnar => Ok((ColdPage::next_page(bytes)?, true)),
}
}
fn table_page_usage(cache: &mut PageCache, table: &Table) -> Result<TablePageUsage> {
let max_hops = cache.backend().page_count().saturating_add(1);
let mut next = table.first_page;
let mut usage = TablePageUsage::default();
let mut cursor_found = table.compaction_cursor.is_none();
let mut tail_found = table.tail_id.is_none();
while let Some(page_id) = next {
if table.compaction_cursor == Some(page_id) {
cursor_found = true;
}
if table.tail_id == Some(page_id) {
tail_found = true;
}
usage.pages = usage.pages.saturating_add(1);
if usage.pages > max_hops {
return Err(PvError::Corruption(
"page chain longer than total page count (cycle?)".into(),
));
}
let (following, used, free, cold, saved) = if Some(page_id) == table.tail_id {
if let Some(tail) = &table.tail {
let (next, used, free) = row_page_usage(tail.as_bytes())?;
(next, used, free, false, 0)
} else {
cache.with_page(page_id, |bytes| page_usage(bytes))?
}
} else {
cache.with_page(page_id, |bytes| page_usage(bytes))?
};
usage.used_bytes = usage.used_bytes.saturating_add(used);
usage.free_bytes = usage.free_bytes.saturating_add(free);
usage.cold_pages = usage.cold_pages.saturating_add(u64::from(cold));
usage.saved_bytes = usage.saved_bytes.saturating_add(saved);
if table.tail_id == Some(page_id) && following.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
next = following;
}
if usage.cold_pages != table.cold_pages {
return Err(PvError::Corruption(format!(
"manifest declares {} cold page(s), page chain contains {}",
table.cold_pages, usage.cold_pages
)));
}
if !cursor_found {
return Err(PvError::Corruption(
"table compaction cursor is outside its page chain".into(),
));
}
if !tail_found {
return Err(PvError::Corruption(
"table page chain does not reach its declared tail".into(),
));
}
Ok(usage)
}
fn column_index(table: &Table, column: &str) -> Result<usize> {
table
.columns
.iter()
.position(|c| c == column)
.ok_or_else(|| PvError::Schema(format!("no column `{column}`")))
}
fn append_record(cache: &mut PageCache, table: &mut Table, record: &[u8]) -> Result<RecordAddr> {
if table.tail.is_none() {
let id = cache.alloc_page()?;
table.tail = Some(RowPage::new(id));
table.tail_id = Some(id);
if let Some(page_ids) = table.page_ids.borrow_mut().as_mut() {
page_ids.insert(id);
}
if table.first_page.is_none() {
table.first_page = Some(id);
}
}
let tail_id = table.tail_id.expect("tail set above");
match table.tail.as_mut().expect("tail set above").insert(record) {
Ok(slot) => {
table.row_versions += 1;
Ok(pack_addr(tail_id, slot))
}
Err(PvError::PageFull { .. }) => {
let new_id = cache.alloc_page()?;
let mut finalized = table.tail.take().expect("tail set above");
finalized.set_next_page(Some(new_id));
cache.write(tail_id, finalized.into_bytes())?;
let mut fresh = RowPage::new(new_id);
let slot = fresh.insert(record)?;
table.tail = Some(fresh);
table.tail_id = Some(new_id);
if let Some(page_ids) = table.page_ids.borrow_mut().as_mut() {
page_ids.insert(new_id);
}
table.row_versions += 1;
Ok(pack_addr(new_id, slot))
}
Err(e) => Err(e),
}
}
fn read_record_at(
cache: &mut PageCache,
table: &Table,
cas: &CasStore,
addr: RecordAddr,
) -> Result<(RecordEnvelope, Row)> {
let (pid, slot) = unpack_addr(addr);
let decoded = if Some(pid) == table.tail_id {
if let Some(tail) = &table.tail {
decode_record(tail.record(slot)?, cas)?
} else {
cache.with_page(pid, |buf| match PageType::try_from(buf[8])? {
PageType::Row => {
let page = RowPageRef::new(buf)?;
decode_record(page.record(slot)?, cas)
}
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
ColdPage::record(buf, slot)
}
})?
}
} else {
cache.with_page(pid, |buf| match PageType::try_from(buf[8])? {
PageType::Row => {
let page = RowPageRef::new(buf)?;
decode_record(page.record(slot)?, cas)
}
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
ColdPage::record(buf, slot)
}
})?
};
if decoded.1.len() != table.columns.len() {
return Err(PvError::Corruption(
"record field count does not match table columns".into(),
));
}
Ok(decoded)
}
fn scan(
cache: &mut PageCache,
table: &Table,
cas: &CasStore,
mut visit: impl FnMut(RecordAddr, &RecordEnvelope, &Row) -> Result<()>,
) -> Result<()> {
let max_hops = cache.backend().page_count().saturating_add(1);
let mut hops = 0u64;
let mut cold_pages = 0u64;
let mut record_versions = 0u64;
let mut tail_found = table.tail_id.is_none();
let mut next = table.first_page;
while let Some(pid) = next {
hops += 1;
if hops > max_hops {
return Err(PvError::Corruption(
"page chain longer than total page count (cycle?)".into(),
));
}
let is_tail = Some(pid) == table.tail_id;
if is_tail {
tail_found = true;
}
if is_tail {
if let Some(tail) = &table.tail {
for slot in 0..tail.slot_count() {
let (env, row) = decode_record(tail.record(slot)?, cas)?;
if row.len() != table.columns.len() {
return Err(PvError::Corruption(
"record field count does not match table columns".into(),
));
}
record_versions = record_versions.saturating_add(1);
visit(pack_addr(pid, slot), &env, &row)?;
}
next = tail.next_page();
if next.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
continue;
}
}
next = cache.with_page(pid, |buf| match PageType::try_from(buf[8])? {
PageType::Row => {
let page = RowPageRef::new(buf)?;
for slot in 0..page.slot_count() {
let (env, row) = decode_record(page.record(slot)?, cas)?;
if row.len() != table.columns.len() {
return Err(PvError::Corruption(
"record field count does not match table columns".into(),
));
}
record_versions = record_versions.saturating_add(1);
visit(pack_addr(pid, slot), &env, &row)?;
}
Ok(page.next_page())
}
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
cold_pages += 1;
if cold_pages > table.cold_pages {
return Err(PvError::Corruption(
"page chain contains more cold pages than the manifest declares".into(),
));
}
let records = ColdPage::records(buf)?;
for (slot, (env, row)) in records.into_iter().enumerate() {
if row.len() != table.columns.len() {
return Err(PvError::Corruption(
"record field count does not match table columns".into(),
));
}
let slot = u16::try_from(slot)
.map_err(|_| PvError::Corruption("cold-page slot overflow".into()))?;
record_versions = record_versions.saturating_add(1);
visit(pack_addr(pid, slot), &env, &row)?;
}
ColdPage::next_page(buf)
}
})?;
if is_tail && next.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
}
if cold_pages != table.cold_pages {
return Err(PvError::Corruption(format!(
"manifest declares {} cold page(s), page chain contains {cold_pages}",
table.cold_pages
)));
}
if !tail_found {
return Err(PvError::Corruption(
"table page chain does not reach its declared tail".into(),
));
}
if record_versions != table.row_versions {
return Err(PvError::Corruption(format!(
"manifest declares {} record version(s), page chain contains {record_versions}",
table.row_versions
)));
}
Ok(())
}
fn scan_envelopes(
cache: &mut PageCache,
table: &Table,
mut visit: impl FnMut(&RecordEnvelope) -> Result<()>,
) -> Result<()> {
let max_hops = cache.backend().page_count().saturating_add(1);
let mut hops = 0u64;
let mut cold_pages = 0u64;
let mut record_versions = 0u64;
let mut tail_found = table.tail_id.is_none();
let mut next = table.first_page;
while let Some(pid) = next {
hops += 1;
if hops > max_hops {
return Err(PvError::Corruption(
"page chain longer than total page count (cycle?)".into(),
));
}
let is_tail = Some(pid) == table.tail_id;
if is_tail {
tail_found = true;
}
if is_tail {
if let Some(tail) = &table.tail {
for slot in 0..tail.slot_count() {
record_versions = record_versions.saturating_add(1);
visit(&RecordEnvelope::decode(tail.record(slot)?)?)?;
}
next = tail.next_page();
if next.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
continue;
}
}
next = cache.with_page(pid, |buf| match PageType::try_from(buf[8])? {
PageType::Row => {
let page = RowPageRef::new(buf)?;
for slot in 0..page.slot_count() {
record_versions = record_versions.saturating_add(1);
visit(&RecordEnvelope::decode(page.record(slot)?)?)?;
}
Ok(page.next_page())
}
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
cold_pages += 1;
if cold_pages > table.cold_pages {
return Err(PvError::Corruption(
"page chain contains more cold pages than the manifest declares".into(),
));
}
let (envelopes, next) = ColdPage::envelopes(buf)?;
for envelope in envelopes {
record_versions = record_versions.saturating_add(1);
visit(&envelope)?;
}
Ok(next)
}
})?;
if is_tail && next.is_some() {
return Err(PvError::Corruption(
"table tail page links to another page".into(),
));
}
}
if cold_pages != table.cold_pages {
return Err(PvError::Corruption(format!(
"manifest declares {} cold page(s), page chain contains {cold_pages}",
table.cold_pages
)));
}
if !tail_found {
return Err(PvError::Corruption(
"table page chain does not reach its declared tail".into(),
));
}
if record_versions != table.row_versions {
return Err(PvError::Corruption(format!(
"manifest declares {} record version(s), page chain contains {record_versions}",
table.row_versions
)));
}
Ok(())
}
fn patch_delete_at(
cache: &mut PageCache,
table: &mut Table,
addr: RecordAddr,
tx: TxId,
) -> Result<()> {
let (pid, slot) = unpack_addr(addr);
if !table_chain_contains_page(cache, table, pid)? {
return Err(PvError::Corruption(format!(
"record address {addr} points outside its table page chain"
)));
}
if Some(pid) == table.tail_id {
if let Some(tail) = table.tail.as_mut() {
return tail.patch_envelope_deleted(slot, tx);
}
}
cache.with_page_bytes_mut(pid, |bytes| match PageType::try_from(bytes[8])? {
PageType::Row => {
let mut page = RowPage::from_bytes(Box::new(*bytes))?;
page.patch_envelope_deleted(slot, tx)?;
*bytes = *page.into_bytes();
Ok(())
}
PageType::Columnar => {
if table.cold_pages == 0 {
return Err(PvError::Corruption(
"table contains an undeclared cold page".into(),
));
}
ColdPage::patch_envelope_deleted(bytes, slot, tx)
}
})
}
fn slice_index_region<'a>(
image: &'a [u8],
manifest: &Manifest,
cas_offset: u64,
manifest_offset: usize,
) -> Result<&'a [u8]> {
match manifest.index_region {
None => Ok(&[]),
Some((off, len)) => {
if off < cas_offset {
return Err(PvError::Corruption(
"index region overlaps the CAS pool".into(),
));
}
let off = usize::try_from(off)
.map_err(|_| PvError::Corruption("index region offset is too large".into()))?;
let len = usize::try_from(len)
.map_err(|_| PvError::Corruption("index region length is too large".into()))?;
let end = off
.checked_add(len)
.filter(|&e| e <= image.len() && e <= manifest_offset)
.ok_or_else(|| PvError::Corruption("index region out of bounds".into()))?;
Ok(&image[off..end])
}
}
}
fn cas_pool_end(manifest: &Manifest, cas_offset: usize, manifest_offset: usize) -> Result<usize> {
let end = match manifest.index_region {
Some((off, _)) => usize::try_from(off)
.map_err(|_| PvError::Corruption("index region offset is too large".into()))?,
None => manifest_offset,
};
if end < cas_offset || end > manifest_offset {
return Err(PvError::Corruption(
"CAS pool / index region bounds are inconsistent".into(),
));
}
Ok(end)
}
fn build_tables(
cache: &mut PageCache,
cas: &CasStore,
manifest: &Manifest,
writable: bool,
index_region: &[u8],
) -> Result<BTreeMap<String, Table>> {
let mut tables = BTreeMap::new();
let page_count = cache.backend().page_count();
for meta in &manifest.tables {
if meta.name.is_empty() {
return Err(PvError::Corruption(
"manifest contains a table with an empty name".into(),
));
}
if tables.contains_key(&meta.name) {
return Err(PvError::Corruption(format!(
"manifest contains duplicate table `{}`",
meta.name
)));
}
validate_schema_metadata(
&meta.name,
&meta.columns,
&meta.unique_columns,
&meta.not_null_columns,
&meta.defaults,
&meta.checks,
true,
)?;
let loaded_tail = match (meta.first_page, meta.tail_id) {
(None, None) if meta.row_versions == 0 => None,
(None, None) => {
return Err(PvError::Corruption(format!(
"table `{}` has row versions but no page chain",
meta.name
)));
}
(Some(_), Some(_)) if meta.row_versions == 0 => {
return Err(PvError::Corruption(format!(
"table `{}` has a page chain but no row versions",
meta.name
)));
}
(Some(first), Some(tail)) => {
if first >= page_count || tail >= page_count || first > tail {
return Err(PvError::Corruption(format!(
"table `{}` has invalid head/tail page ids ({first}, {tail}) for {page_count} pages",
meta.name
)));
}
if writable {
let buf = cache.backend().read_page(tail)?;
verify_page_checksum(tail, &buf)?;
let tail_page = RowPage::from_bytes(buf)?;
if tail_page.next_page().is_some() {
return Err(PvError::Corruption(format!(
"table `{}` tail page {tail} links to another page",
meta.name
)));
}
Some(tail_page)
} else {
None
}
}
_ => {
return Err(PvError::Corruption(format!(
"table `{}` must define both first_page and tail_id, or neither",
meta.name
)));
}
};
let table = Table {
columns: meta.columns.clone(),
unique_columns: meta.unique_columns.iter().cloned().collect(),
not_null_columns: meta.not_null_columns.iter().cloned().collect(),
defaults: meta.defaults.clone(),
checks: meta.checks.clone(),
first_page: meta.first_page,
tail_id: meta.tail_id,
tail: loaded_tail,
row_versions: meta.row_versions,
cold_pages: meta.cold_pages,
compaction_cursor: meta.compaction_cursor,
page_ids: RefCell::new(None),
indexes: BTreeMap::new(),
};
tables.insert(meta.name.clone(), table);
}
for meta in &manifest.tables {
if !meta.binary_indexes.is_empty() {
let table = tables.get_mut(&meta.name).expect("just inserted");
for desc in &meta.binary_indexes {
let start = usize::try_from(desc.offset).map_err(|_| {
PvError::Corruption("index region descriptor offset is too large".into())
})?;
let len = usize::try_from(desc.len).map_err(|_| {
PvError::Corruption("index region descriptor length is too large".into())
})?;
let end = start
.checked_add(len)
.filter(|&e| e <= index_region.len())
.ok_or_else(|| {
PvError::Corruption("index region descriptor out of bounds".into())
})?;
table.indexes.insert(
desc.column.clone(),
SecondaryIndex::decode_binary(&index_region[start..end])?,
);
}
} else if !meta.indexes.is_empty() {
let table = tables.get_mut(&meta.name).expect("just inserted");
for pi in &meta.indexes {
table.indexes.insert(
pi.column.clone(),
SecondaryIndex::from_pairs(pi.pairs.clone()),
);
}
}
{
let table = tables.get(&meta.name).expect("just inserted");
let mut rebuilt = Vec::new();
let mut desired: BTreeSet<_> = meta.indexed_columns.iter().collect();
if writable {
desired.extend(meta.unique_columns.iter());
}
for column in desired {
if table.indexes.contains_key(column) {
continue;
}
rebuilt.push((
column.clone(),
column_index(table, column)?,
SecondaryIndex::new(),
));
}
if !rebuilt.is_empty() {
scan(cache, table, cas, |addr, _env, row| {
for (_, col_ix, index) in &mut rebuilt {
index.insert(&row[*col_ix], addr);
}
Ok(())
})?;
}
for (column, _, index) in rebuilt {
tables
.get_mut(&meta.name)
.expect("just inserted")
.indexes
.insert(column, index);
}
}
}
Ok(tables)
}
#[cfg(test)]
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn transaction_lock_drop_releases_duplicated_description() {
let temp = tempfile::tempdir().unwrap();
let lock = acquire_transaction_lock(temp.path()).unwrap();
let inherited = lock.0.try_clone().unwrap();
assert!(acquire_transaction_lock(temp.path()).is_err());
drop(lock);
let next = acquire_transaction_lock(temp.path()).unwrap();
drop(inherited);
assert!(acquire_transaction_lock(temp.path()).is_err());
drop(next);
assert!(acquire_transaction_lock(temp.path()).is_ok());
}
#[test]
fn dev_insert_select_and_reopen() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
{
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE users (id, name)").unwrap();
db.query("INSERT INTO users VALUES (1, 'alice')").unwrap();
db.query("INSERT INTO users VALUES (2, 'bob')").unwrap();
assert_eq!(
db.query("SELECT * FROM users")
.unwrap()
.rows()
.unwrap()
.len(),
2
);
}
let mut db = Database::open_dev(&ws).unwrap();
assert_eq!(
db.query("SELECT * FROM users")
.unwrap()
.rows()
.unwrap()
.len(),
2
);
assert_eq!(db.table_names(), vec!["users".to_string()]);
}
#[test]
fn delete_and_time_travel() {
let tmp = tempfile::tempdir().unwrap();
let mut db = Database::open_dev(tmp.path().join("ws")).unwrap();
db.query("CREATE TABLE t (id)").unwrap();
db.query("INSERT INTO t VALUES (1)").unwrap();
db.query("INSERT INTO t VALUES (2)").unwrap();
let before_delete = db.current_tx();
assert_eq!(db.delete("t", "id", &Value::Int(1)).unwrap(), 1);
let now = db.query("SELECT * FROM t").unwrap();
assert_eq!(now.rows().unwrap().len(), 1);
assert_eq!(now.rows().unwrap()[0][0], Value::Int(2));
let past = db
.query(&format!("SELECT * FROM t BEFORE {before_delete}"))
.unwrap();
assert_eq!(past.rows().unwrap().len(), 2);
}
#[test]
fn for_each_row_streams_visible_rows() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, name)").unwrap();
for i in 1..=5 {
db.query(&format!("INSERT INTO t VALUES ({i}, 'r{i}')"))
.unwrap();
}
let before_delete = db.current_tx();
db.query("DELETE FROM t WHERE id = 3").unwrap();
let mut ids = Vec::new();
db.for_each_row("t", None, |row| {
if let Value::Int(i) = row[0] {
ids.push(i);
}
Ok(())
})
.unwrap();
ids.sort();
assert_eq!(ids, vec![1, 2, 4, 5]);
let mut count = 0;
db.for_each_row("t", Some(before_delete), |_row| {
count += 1;
Ok(())
})
.unwrap();
assert_eq!(count, 5);
let stopped = db.for_each_row("t", None, |_row| Err(PvError::Query("stop".into())));
assert!(stopped.is_err());
assert_eq!(
db.column_names("t").unwrap(),
vec!["id".to_string(), "name".to_string()]
);
assert!(db.column_names("nope").is_err());
assert!(db.for_each_row("nope", None, |_| Ok(())).is_err());
}
#[test]
fn projection_order_by_and_count() {
let mut db = Database::open_memory();
db.query("CREATE TABLE p (id, name)").unwrap();
db.query("INSERT INTO p VALUES (3, 'carol')").unwrap();
db.query("INSERT INTO p VALUES (1, 'alice')").unwrap();
db.query("INSERT INTO p VALUES (2, 'bob')").unwrap();
let c = db.query("SELECT COUNT(*) FROM p").unwrap();
assert_eq!(c.columns().unwrap(), &["count".to_string()]);
assert_eq!(c.rows().unwrap(), &[vec![Value::Int(3)]]);
let asc = db.query("SELECT id FROM p ORDER BY id").unwrap();
assert_eq!(asc.columns().unwrap(), &["id".to_string()]);
let ids: Vec<_> = asc.rows().unwrap().iter().map(|r| r[0].clone()).collect();
assert_eq!(ids, vec![Value::Int(1), Value::Int(2), Value::Int(3)]);
let desc = db.query("SELECT name FROM p ORDER BY id DESC").unwrap();
assert_eq!(desc.columns().unwrap(), &["name".to_string()]);
let names: Vec<_> = desc.rows().unwrap().iter().map(|r| r[0].clone()).collect();
assert_eq!(
names,
vec![
Value::Text("carol".into()),
Value::Text("bob".into()),
Value::Text("alice".into()),
]
);
let proj = db
.query("SELECT name, id FROM p ORDER BY name LIMIT 2")
.unwrap();
assert_eq!(
proj.columns().unwrap(),
&["name".to_string(), "id".to_string()]
);
assert_eq!(
proj.rows().unwrap(),
&[
vec![Value::Text("alice".into()), Value::Int(1)],
vec![Value::Text("bob".into()), Value::Int(2)],
]
);
assert!(db.query("SELECT nope FROM p").is_err());
assert!(db.query("SELECT * FROM p ORDER BY nope").is_err());
}
fn ids(db: &mut Database, sql: &str) -> Vec<i64> {
let r = db.query(sql).unwrap();
let ix = r.columns().unwrap().iter().position(|c| c == "id").unwrap();
let mut v: Vec<i64> = r
.rows()
.unwrap()
.iter()
.map(|row| match row[ix] {
Value::Int(i) => i,
ref other => panic!("non-int id: {other:?}"),
})
.collect();
v.sort();
v
}
#[test]
fn where_comparisons_boolean_and_like() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, name, age)").unwrap();
db.query("INSERT INTO t VALUES (1, 'alice', 30)").unwrap();
db.query("INSERT INTO t VALUES (2, 'bob', 25)").unwrap();
db.query("INSERT INTO t VALUES (3, 'carol', 40)").unwrap();
db.query("INSERT INTO t VALUES (4, 'dave', 25)").unwrap();
assert_eq!(ids(&mut db, "SELECT * FROM t WHERE age > 25"), vec![1, 3]);
assert_eq!(ids(&mut db, "SELECT * FROM t WHERE age >= 30"), vec![1, 3]);
assert_eq!(ids(&mut db, "SELECT * FROM t WHERE age != 25"), vec![1, 3]);
assert_eq!(ids(&mut db, "SELECT id FROM t WHERE id < 3"), vec![1, 2]);
assert_eq!(ids(&mut db, "SELECT id FROM t WHERE id <= 2"), vec![1, 2]);
assert_eq!(
ids(&mut db, "SELECT * FROM t WHERE age = 25 OR id = 1"),
vec![1, 2, 4]
);
assert_eq!(
ids(&mut db, "SELECT * FROM t WHERE age > 25 AND id < 3"),
vec![1]
);
assert_eq!(
ids(
&mut db,
"SELECT * FROM t WHERE (id = 1 OR id = 4) AND age = 25"
),
vec![4]
);
assert_eq!(
ids(&mut db, "SELECT * FROM t WHERE name LIKE 'a%'"),
vec![1]
);
assert_eq!(
ids(&mut db, "SELECT id FROM t WHERE name LIKE '_a%'"),
vec![3, 4]
);
}
#[test]
fn whole_table_aggregates() {
let mut db = Database::open_memory();
db.query("CREATE TABLE s (id, amount)").unwrap();
db.query("INSERT INTO s VALUES (1, 10)").unwrap();
db.query("INSERT INTO s VALUES (2, 30)").unwrap();
db.query("INSERT INTO s VALUES (3, 20)").unwrap();
let r = db
.query("SELECT COUNT(*), SUM(amount), MIN(amount), MAX(amount) FROM s")
.unwrap();
assert_eq!(
r.columns().unwrap(),
&["count", "sum(amount)", "min(amount)", "max(amount)"]
);
assert_eq!(
r.rows().unwrap(),
&[vec![
Value::Int(3),
Value::Int(60),
Value::Int(10),
Value::Int(30)
]]
);
let r = db
.query("SELECT SUM(amount) FROM s WHERE amount >= 20")
.unwrap();
assert_eq!(r.rows().unwrap(), &[vec![Value::Int(50)]]);
db.query("CREATE TABLE w (name)").unwrap();
db.query("INSERT INTO w VALUES ('bob')").unwrap();
db.query("INSERT INTO w VALUES ('alice')").unwrap();
let r = db.query("SELECT MIN(name), MAX(name) FROM w").unwrap();
assert_eq!(
r.rows().unwrap(),
&[vec![Value::Text("alice".into()), Value::Text("bob".into())]]
);
assert!(db.query("SELECT SUM(name) FROM w").is_err());
}
#[test]
fn group_by_aggregates() {
let mut db = Database::open_memory();
db.query("CREATE TABLE orders (id, customer, amount)")
.unwrap();
for (i, c, a) in [
(1, "alice", 120),
(2, "bob", 45),
(3, "alice", 60),
(4, "carol", 200),
(5, "bob", 55),
] {
db.query(&format!("INSERT INTO orders VALUES ({i}, '{c}', {a})"))
.unwrap();
}
let r = db
.query("SELECT customer, COUNT(*), SUM(amount) FROM orders GROUP BY customer")
.unwrap();
assert_eq!(
r.columns().unwrap(),
&[
"customer".to_string(),
"count".to_string(),
"sum(amount)".to_string()
]
);
assert_eq!(
r.rows().unwrap(),
&[
vec![Value::Text("alice".into()), Value::Int(2), Value::Int(180)],
vec![Value::Text("bob".into()), Value::Int(2), Value::Int(100)],
vec![Value::Text("carol".into()), Value::Int(1), Value::Int(200)],
]
);
let r = db
.query("SELECT customer, MIN(amount), MAX(amount) FROM orders WHERE amount > 50 GROUP BY customer")
.unwrap();
assert_eq!(
r.rows().unwrap(),
&[
vec![Value::Text("alice".into()), Value::Int(60), Value::Int(120)],
vec![Value::Text("bob".into()), Value::Int(55), Value::Int(55)],
vec![
Value::Text("carol".into()),
Value::Int(200),
Value::Int(200)
],
]
);
let distinct = db
.query("SELECT customer FROM orders GROUP BY customer")
.unwrap();
let names: Vec<_> = distinct
.rows()
.unwrap()
.iter()
.map(|r| r[0].clone())
.collect();
assert_eq!(
names,
vec![
Value::Text("alice".into()),
Value::Text("bob".into()),
Value::Text("carol".into()),
]
);
assert!(db
.query("SELECT customer, amount FROM orders GROUP BY customer")
.is_err()); assert!(db.query("SELECT * FROM orders GROUP BY customer").is_err()); assert!(db.query("SELECT customer, COUNT(*) FROM orders").is_err()); }
#[test]
fn avg_aggregate() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, amount)").unwrap();
db.query("INSERT INTO t VALUES (1, 1)").unwrap();
db.query("INSERT INTO t VALUES (2, 2)").unwrap();
let r = db.query("SELECT AVG(amount) FROM t").unwrap();
assert_eq!(r.columns().unwrap(), &["avg(amount)".to_string()]);
assert_eq!(r.rows().unwrap(), &[vec![Value::Decimal(1_500_000)]]);
assert_eq!(r.rows().unwrap()[0][0].to_string(), "1.500000");
db.query("INSERT INTO t VALUES (3, NULL)").unwrap();
assert_eq!(
db.query("SELECT AVG(amount) FROM t")
.unwrap()
.rows()
.unwrap(),
&[vec![Value::Decimal(1_500_000)]]
);
db.query("INSERT INTO t VALUES (4, 9)").unwrap(); assert_eq!(
db.query("SELECT AVG(amount) FROM t")
.unwrap()
.rows()
.unwrap(),
&[vec![Value::Decimal(4_000_000)]]
);
db.query("CREATE TABLE e (x)").unwrap();
assert_eq!(
db.query("SELECT AVG(x) FROM e").unwrap().rows().unwrap(),
&[vec![Value::Null]]
);
db.query("INSERT INTO e VALUES (NULL)").unwrap();
assert_eq!(
db.query("SELECT AVG(x) FROM e").unwrap().rows().unwrap(),
&[vec![Value::Null]]
);
db.query("CREATE TABLE w (name)").unwrap();
db.query("INSERT INTO w VALUES ('bob')").unwrap();
assert!(db.query("SELECT AVG(name) FROM w").is_err());
let mut g = Database::open_memory();
g.query("CREATE TABLE s (team, score)").unwrap();
for (t, sc) in [("a", 10), ("a", 20), ("b", 5), ("b", 6)] {
g.query(&format!("INSERT INTO s VALUES ('{t}', {sc})"))
.unwrap();
}
let r = g
.query("SELECT team, AVG(score) FROM s GROUP BY team")
.unwrap();
assert_eq!(
r.rows().unwrap(),
&[
vec![Value::Text("a".into()), Value::Decimal(15_000_000)],
vec![Value::Text("b".into()), Value::Decimal(5_500_000)],
]
);
}
#[test]
fn avg_is_exact_and_rounds_half_away_from_zero() {
let mut big = Database::open_memory();
big.query("CREATE TABLE b (v)").unwrap();
big.query("INSERT INTO b VALUES (9223372036854775807)")
.unwrap();
let avg = big.query("SELECT AVG(v) FROM b").unwrap();
assert_eq!(
avg.rows().unwrap(),
&[vec![Value::Decimal(
9_223_372_036_854_775_807_i128 * 1_000_000
)]]
);
assert_eq!(
avg.rows().unwrap()[0][0].to_string(),
"9223372036854775807.000000"
);
let mut exact = Database::open_memory();
exact.query("CREATE TABLE r (v)").unwrap();
for v in [5, 0, 0, 0, 0, 0, 0, 0] {
exact.query(&format!("INSERT INTO r VALUES ({v})")).unwrap();
}
assert_eq!(
exact.query("SELECT AVG(v) FROM r").unwrap().rows().unwrap(),
&[vec![Value::Decimal(625_000)]]
);
let mut half = Database::open_memory();
half.query("CREATE TABLE h (v)").unwrap();
for i in 0..128 {
let v = if i == 0 { 1 } else { 0 };
half.query(&format!("INSERT INTO h VALUES ({v})")).unwrap();
}
let r = half.query("SELECT AVG(v) FROM h").unwrap();
assert_eq!(r.rows().unwrap(), &[vec![Value::Decimal(7813)]]);
assert_eq!(r.rows().unwrap()[0][0].to_string(), "0.007813");
let mut neg = Database::open_memory();
neg.query("CREATE TABLE n (v)").unwrap();
neg.query("INSERT INTO n VALUES (-1)").unwrap();
neg.query("INSERT INTO n VALUES (-2)").unwrap();
let r = neg.query("SELECT AVG(v) FROM n").unwrap();
assert_eq!(r.rows().unwrap(), &[vec![Value::Decimal(-1_500_000)]]);
assert_eq!(r.rows().unwrap()[0][0].to_string(), "-1.500000");
let mut minimum = Database::open_memory();
minimum.query("CREATE TABLE minimum (v)").unwrap();
minimum
.insert("minimum", vec![Value::Decimal(i128::MIN)])
.unwrap();
assert_eq!(
minimum
.query("SELECT AVG(v) FROM minimum")
.unwrap()
.rows()
.unwrap(),
&[vec![Value::Decimal(i128::MIN)]]
);
}
#[test]
fn decimal_literals_are_storable_and_round_trip() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (x)").unwrap();
db.insert("t", vec![Value::Decimal(1_500_000)]).unwrap();
db.query("INSERT INTO t VALUES (12.50)").unwrap();
db.query("INSERT INTO t VALUES (-0.0000019)").unwrap();
let rows = db
.query("SELECT * FROM t")
.unwrap()
.rows()
.unwrap()
.to_vec();
assert_eq!(
rows,
vec![
vec![Value::Decimal(1_500_000)],
vec![Value::Decimal(12_500_000)],
vec![Value::Decimal(-1)],
]
);
let bytes = db.bake_to_bytes().unwrap();
let mut restored = Database::import_bytes(&bytes).unwrap();
assert_eq!(
restored
.query("SELECT * FROM t")
.unwrap()
.rows()
.unwrap()
.len(),
3
);
}
#[test]
fn parameterized_queries_bind_safely() {
let mut db = Database::open_memory();
db.query("CREATE TABLE u (id, name)").unwrap();
db.query_with(
"INSERT INTO u VALUES (?, ?)",
&[Value::Int(1), Value::Text("a'b".into())],
)
.unwrap();
db.query_with("INSERT INTO u VALUES (?, ?)", &[Value::Int(2), Value::Null])
.unwrap();
db.query_with("INSERT INTO u VALUES (3, '?')", &[]).unwrap();
let rows = db
.query_with("SELECT name FROM u WHERE id = ?", &[Value::Int(1)])
.unwrap()
.rows()
.unwrap()
.to_vec();
assert_eq!(rows, vec![vec![Value::Text("a'b".into())]]);
db.query_with(
"INSERT INTO u VALUES (4, ?)",
&[Value::Text("x'); DROP TABLE u; --".into())],
)
.unwrap();
assert_eq!(
db.query("SELECT COUNT(*) FROM u").unwrap().rows().unwrap(),
&[vec![Value::Int(4)]]
);
assert!(db.query_with("SELECT * FROM u WHERE id = ?", &[]).is_err());
assert!(db
.query_with(
"SELECT * FROM u WHERE id = ?",
&[Value::Int(1), Value::Int(2)]
)
.is_err());
}
#[test]
fn sum_of_empty_or_all_null_is_null() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (x)").unwrap();
assert_eq!(
db.query("SELECT SUM(x) FROM t").unwrap().rows().unwrap(),
&[vec![Value::Null]]
);
db.query("INSERT INTO t VALUES (NULL)").unwrap();
assert_eq!(
db.query("SELECT SUM(x) FROM t").unwrap().rows().unwrap(),
&[vec![Value::Null]]
);
db.query("INSERT INTO t VALUES (7)").unwrap();
assert_eq!(
db.query("SELECT SUM(x) FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(7)]]
);
}
#[test]
fn update_and_delete_with_predicates() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, tier)").unwrap();
for i in 1..=5 {
db.query(&format!("INSERT INTO t VALUES ({i}, 'free')"))
.unwrap();
}
assert_eq!(
db.query("UPDATE t SET tier = 'pro' WHERE id > 3").unwrap(),
QueryResult::Mutated(2)
);
let pros = db
.query("SELECT COUNT(*) FROM t WHERE tier = 'pro'")
.unwrap();
assert_eq!(pros.rows().unwrap(), &[vec![Value::Int(2)]]);
assert_eq!(
db.query("DELETE FROM t WHERE id = 1 OR id = 2").unwrap(),
QueryResult::Mutated(2)
);
assert_eq!(ids(&mut db, "SELECT id FROM t"), vec![3, 4, 5]);
}
#[test]
fn indexed_equality_used_within_and_predicate() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, tier)").unwrap();
db.query("INSERT INTO t VALUES (1, 'pro')").unwrap();
db.query("INSERT INTO t VALUES (2, 'free')").unwrap();
db.query("INSERT INTO t VALUES (3, 'pro')").unwrap();
db.query("CREATE INDEX ON t (tier)").unwrap();
assert_eq!(
ids(&mut db, "SELECT id FROM t WHERE tier = 'pro' AND id > 1"),
vec![3]
);
assert_eq!(
ids(&mut db, "SELECT id FROM t WHERE tier = 'free'"),
vec![2]
);
}
#[test]
fn range_query_with_index_matches_scan() {
let build = |index: bool| {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, score)").unwrap();
for (i, s) in [(1, 50), (2, 90), (3, 70), (4, 90), (5, 10)] {
db.query(&format!("INSERT INTO t VALUES ({i}, {s})"))
.unwrap();
}
if index {
db.query("CREATE INDEX ON t (score)").unwrap();
}
db
};
let mut indexed = build(true);
let mut plain = build(false);
for sql in [
"SELECT id FROM t WHERE score > 50",
"SELECT id FROM t WHERE score >= 70",
"SELECT id FROM t WHERE score < 70",
"SELECT id FROM t WHERE score <= 50",
"SELECT id FROM t WHERE score > 10 AND score < 90",
"SELECT id FROM t WHERE score = 90",
] {
assert_eq!(
ids(&mut indexed, sql),
ids(&mut plain, sql),
"mismatch: {sql}"
);
}
assert_eq!(
ids(&mut indexed, "SELECT id FROM t WHERE score >= 70"),
vec![2, 3, 4]
);
indexed
.query("UPDATE t SET score = 5 WHERE id = 2")
.unwrap();
assert_eq!(
ids(&mut indexed, "SELECT id FROM t WHERE score >= 70"),
vec![3, 4]
);
assert_eq!(
ids(&mut indexed, "SELECT id FROM t WHERE score < 50"),
vec![2, 5]
);
}
#[test]
fn order_by_index_matches_sort() {
let build = |index: bool| {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, score)").unwrap();
for (i, s) in [(1, 50), (2, 90), (3, 70), (4, 90), (5, 10)] {
db.query(&format!("INSERT INTO t VALUES ({i}, {s})"))
.unwrap();
}
if index {
db.query("CREATE INDEX ON t (score)").unwrap();
}
db
};
let mut indexed = build(true);
let mut plain = build(false);
let scores = |db: &mut Database, sql: &str| -> Vec<i64> {
let r = db.query(sql).unwrap();
let si = r
.columns()
.unwrap()
.iter()
.position(|c| c == "score")
.unwrap();
r.rows()
.unwrap()
.iter()
.map(|row| match row[si] {
Value::Int(v) => v,
ref other => panic!("non-int score: {other:?}"),
})
.collect()
};
for sql in [
"SELECT score, id FROM t ORDER BY score",
"SELECT score, id FROM t ORDER BY score ASC",
"SELECT score, id FROM t ORDER BY score DESC",
"SELECT score, id FROM t ORDER BY score LIMIT 3",
"SELECT score, id FROM t ORDER BY score DESC LIMIT 2",
] {
assert_eq!(
scores(&mut indexed, sql),
scores(&mut plain, sql),
"order: {sql}"
);
}
assert_eq!(
scores(&mut indexed, "SELECT score FROM t ORDER BY score"),
vec![10, 50, 70, 90, 90]
);
assert_eq!(
scores(
&mut indexed,
"SELECT score FROM t ORDER BY score DESC LIMIT 2"
),
vec![90, 90]
);
let proj = indexed
.query("SELECT id FROM t ORDER BY score LIMIT 1")
.unwrap();
assert_eq!(proj.columns().unwrap(), &["id".to_string()]);
assert_eq!(proj.rows().unwrap(), &[vec![Value::Int(5)]]);
indexed.query("DELETE FROM t WHERE id = 5").unwrap();
assert_eq!(
scores(&mut indexed, "SELECT score FROM t ORDER BY score"),
vec![50, 70, 90, 90]
);
}
#[test]
fn bake_then_open_prod_with_cas_blob() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
let monolith = tmp.path().join("app.pvdb");
let big = "z".repeat(100);
{
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE docs (id, body)").unwrap();
db.insert("docs", vec![Value::Int(1), Value::Text(big.clone())])
.unwrap();
db.bake(&monolith).unwrap();
}
let mut prod = Database::open_prod(&monolith).unwrap();
assert!(!prod.is_writable());
let rows = prod.query("SELECT * FROM docs").unwrap();
assert_eq!(rows.rows().unwrap()[0][1], Value::Text(big));
assert!(matches!(
prod.query("INSERT INTO docs VALUES (2, 'x')"),
Err(PvError::ReadOnly)
));
}
#[test]
fn spans_many_pages_with_a_tiny_cache() {
let tmp = tempfile::tempdir().unwrap();
let mut db = Database::open_dev(tmp.path().join("ws")).unwrap();
db.set_autocommit(false);
db.set_cache_capacity(4).unwrap();
db.query("CREATE TABLE t (id, pad)").unwrap();
for i in 0..5_000i64 {
db.insert("t", vec![Value::Int(i), Value::Int(i * 3)])
.unwrap();
}
db.flush_now().unwrap();
let (_c, rows) = db.select("t", None).unwrap();
assert_eq!(rows.len(), 5_000);
assert!(db.cache_resident() <= 5, "buffer pool must stay bounded");
assert_eq!(rows[4_999], vec![Value::Int(4_999), Value::Int(14_997)]);
}
#[test]
fn index_lookup_matches_scan_and_survives_reopen() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
{
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE events (id, kind)").unwrap();
db.set_autocommit(false);
for i in 0..1_000i64 {
let kind = if i % 7 == 0 { "rare" } else { "common" };
db.insert("events", vec![Value::Int(i), Value::from(kind)])
.unwrap();
}
db.query("CREATE INDEX ON events (kind)").unwrap();
db.flush_now().unwrap();
let indexed = db
.query("SELECT * FROM events WHERE kind = 'rare'")
.unwrap();
assert_eq!(indexed.rows().unwrap().len(), 143); }
let mut db = Database::open_dev(&ws).unwrap();
let indexed = db
.query("SELECT * FROM events WHERE kind = 'rare'")
.unwrap();
assert_eq!(indexed.rows().unwrap().len(), 143);
}
#[test]
fn compliance_hook_is_wired_in() {
let tmp = tempfile::tempdir().unwrap();
let db = Database::open_dev(tmp.path().join("ws")).unwrap();
assert!(db.assert_compliance(&RuntimeMetrics::free_tier()).is_ok());
let over = RuntimeMetrics {
current_mau: 60_000,
monthly_revenue: 0.0,
has_authorizing_key: false,
};
assert!(matches!(
db.assert_compliance(&over),
Err(PvError::Compliance(_))
));
}
#[test]
fn wasm_extension_seam_runs_scalar_and_apply() {
let guest = wat::parse_str(
r#"
(module
(memory (export "memory") 1)
(func (export "sum") (param $ptr i32) (param $len i32) (result i32)
(local $i i32) (local $acc i32)
(block $done (loop $loop
(br_if $done (i32.ge_u (local.get $i) (local.get $len)))
(local.set $acc (i32.add (local.get $acc)
(i32.load8_u (i32.add (local.get $ptr) (local.get $i)))))
(local.set $i (i32.add (local.get $i) (i32.const 1)))
(br $loop)))
(local.get $acc))
(func (export "inc") (param $ptr i32) (param $len i32) (result i32)
(local $i i32)
(block $done (loop $loop
(br_if $done (i32.ge_u (local.get $i) (local.get $len)))
(i32.store8 (i32.add (local.get $ptr) (local.get $i))
(i32.add (i32.load8_u (i32.add (local.get $ptr) (local.get $i))) (i32.const 1)))
(local.set $i (i32.add (local.get $i) (i32.const 1)))
(br $loop)))
(local.get $len)))
"#,
)
.unwrap();
let db = Database::open_memory();
assert_eq!(
db.run_wasm_scalar(&guest, "sum", &[1, 2, 3, 4, 10])
.unwrap(),
20
);
assert_eq!(
db.run_wasm_apply(&guest, "inc", &[0, 9, 254]).unwrap(),
vec![1, 10, 255]
);
assert!(db.run_wasm_scalar(&guest, "missing", &[]).is_err());
}
#[test]
fn cyclic_page_chain_errors_rather_than_hangs() {
let tmp = tempfile::tempdir().unwrap();
let mut dev = DevStore::create(tmp.path()).unwrap();
let pid = dev.alloc_page(); let mut cas = CasStore::new_memory();
let record = encode_record(&RecordEnvelope::new(1, 0), &[], &mut cas).unwrap();
let mut page = RowPage::new(pid);
page.insert(&record).unwrap();
page.set_next_page(Some(pid)); dev.write_page(pid, page.as_bytes()).unwrap();
let mut cache = PageCache::new(Backend::Dev(dev), 8);
let table = Table {
columns: vec!["x".into()],
unique_columns: BTreeSet::new(),
not_null_columns: BTreeSet::new(),
defaults: BTreeMap::new(),
checks: Vec::new(),
first_page: Some(pid),
tail_id: None,
tail: None,
row_versions: 0,
cold_pages: 0,
compaction_cursor: None,
page_ids: RefCell::new(None),
indexes: BTreeMap::new(),
};
let result = scan(&mut cache, &table, &cas, |_, _, _| Ok(()));
assert!(result.is_err(), "cyclic chain must error, not hang");
}
#[test]
fn sync_durability_round_trips() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
{
let mut db = Database::open_dev(&ws).unwrap();
db.set_durability(Durability::Sync);
db.query("CREATE TABLE t (id, name)").unwrap();
db.query("INSERT INTO t VALUES (1, 'alice')").unwrap();
db.query("INSERT INTO t VALUES (2, 'bob')").unwrap();
}
let mut db = Database::open_dev(&ws).unwrap();
assert_eq!(
db.query("SELECT * FROM t").unwrap().rows().unwrap().len(),
2
);
assert!(!ws.join("pv_manifest.json.tmp").exists());
}
#[test]
fn filesystem_transaction_commits_all_statements() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
{
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE accounts (id PRIMARY KEY, balance)")
.unwrap();
db.transaction(|tx| {
tx.query("INSERT INTO accounts VALUES (1, 40)")?;
tx.query("INSERT INTO accounts VALUES (2, 60)")?;
Ok(())
})
.unwrap();
assert!(!db.in_transaction());
}
let mut reopened = Database::open_dev(&ws).unwrap();
let rows = reopened
.query("SELECT * FROM accounts ORDER BY id")
.unwrap();
assert_eq!(rows.rows().unwrap().len(), 2);
assert!(!ws.join(TRANSACTION_MARKER_FILE).exists());
assert!(!ws.join(TRANSACTION_BACKUP_DIR).exists());
}
#[test]
fn sql_transaction_control_works_for_filesystem_workspaces() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE t (id)").unwrap();
db.query("BEGIN TRANSACTION").unwrap();
db.query("INSERT INTO t VALUES (1)").unwrap();
db.query("ROLLBACK").unwrap();
assert_eq!(
db.query("SELECT COUNT(*) FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(0)]]
);
db.query("BEGIN").unwrap();
db.query("INSERT INTO t VALUES (2)").unwrap();
db.query("COMMIT TRANSACTION").unwrap();
assert_eq!(
db.query("SELECT * FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(2)]]
);
}
#[test]
fn filesystem_transaction_error_restores_complete_state() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
let mut db = Database::open_dev(&ws).unwrap();
db.query("CREATE TABLE accounts (id PRIMARY KEY, balance)")
.unwrap();
db.query("INSERT INTO accounts VALUES (1, 100)").unwrap();
let before_tx = db.current_tx();
let result = db.transaction(|tx| {
tx.query("UPDATE accounts SET balance = 20 WHERE id = 1")?;
tx.query("INSERT INTO accounts VALUES (2, 80)")?;
Err::<(), _>(PvError::Schema("application rejected transfer".into()))
});
assert!(matches!(result, Err(PvError::Schema(_))));
assert_eq!(db.current_tx(), before_tx);
let rows = db.query("SELECT * FROM accounts ORDER BY id").unwrap();
assert_eq!(
rows.rows().unwrap(),
&[vec![Value::Int(1), Value::Int(100)]]
);
drop(db);
let mut reopened = Database::open_dev(&ws).unwrap();
assert_eq!(
reopened
.query("SELECT * FROM accounts")
.unwrap()
.rows()
.unwrap(),
&[vec![Value::Int(1), Value::Int(100)]]
);
}
#[test]
fn failed_rollback_and_ambiguous_commit_report_unknown_outcome() {
let tmp = tempfile::tempdir().unwrap();
let rollback_ws = tmp.path().join("rollback-failure");
let mut rollback_db = Database::open_dev(&rollback_ws).unwrap();
rollback_db.query("CREATE TABLE t (id)").unwrap();
let rollback_result = rollback_db.transaction(|_| {
fs::remove_dir_all(rollback_ws.join(TRANSACTION_BACKUP_DIR)).unwrap();
Err::<(), _>(PvError::Query("forced operation failure".into()))
});
assert!(matches!(
rollback_result,
Err(PvError::TransactionOutcomeUnknown(_))
));
assert!(!rollback_db.in_transaction());
let mutation_ws = tmp.path().join("mutation-rollback-failure");
let mut mutation_db = Database::open_dev(&mutation_ws).unwrap();
mutation_db.query("CREATE TABLE t (id)").unwrap();
mutation_db.begin_transaction().unwrap();
fs::remove_dir_all(mutation_ws.join(TRANSACTION_BACKUP_DIR)).unwrap();
let mutation_result = mutation_db
.atomic_mutation(|_| Err::<(), _>(PvError::Query("forced statement failure".into())));
assert!(matches!(
mutation_result,
Err(PvError::TransactionOutcomeUnknown(_))
));
assert!(!mutation_db.in_transaction());
let commit_ws = tmp.path().join("commit-failure");
let mut commit_db = Database::open_dev(&commit_ws).unwrap();
commit_db.query("CREATE TABLE t (id)").unwrap();
let commit_result = commit_db.transaction(|_| {
fs::remove_file(commit_ws.join(TRANSACTION_MARKER_FILE)).unwrap();
Ok(())
});
assert!(matches!(
commit_result,
Err(PvError::TransactionOutcomeUnknown(_))
));
assert!(!commit_db.in_transaction());
}
#[test]
fn statement_mutation_failure_rolls_back_implicit_and_explicit_transactions() {
let injected_io = || std::io::Error::other("injected statement write failure");
let mut implicit = Database::open_memory();
implicit.query("CREATE TABLE t (id)").unwrap();
implicit.query("INSERT INTO t VALUES (1)").unwrap();
let before = implicit.current_tx();
let error = implicit
.atomic_mutation(|database| {
database.insert_validated("t", vec![Value::Int(2)])?;
database.insert_validated("t", vec![Value::Int(3)])?;
Err::<(), _>(PvError::Io(injected_io()))
})
.unwrap_err();
assert!(matches!(error, PvError::Io(_)));
assert!(!implicit.in_transaction());
assert_eq!(implicit.current_tx(), before);
assert_eq!(
implicit.query("SELECT * FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(1)]]
);
let mut explicit = Database::open_memory();
explicit.query("CREATE TABLE t (id)").unwrap();
explicit.query("INSERT INTO t VALUES (1)").unwrap();
explicit.begin_transaction().unwrap();
explicit.query("INSERT INTO t VALUES (2)").unwrap();
let error = explicit
.atomic_mutation(|database| {
database.insert_validated("t", vec![Value::Int(3)])?;
Err::<(), _>(PvError::Io(injected_io()))
})
.unwrap_err();
assert!(matches!(error, PvError::Io(_)));
assert!(
!explicit.in_transaction(),
"a mutation-phase failure must abort the outer transaction"
);
assert_eq!(
explicit.query("SELECT * FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(1)]],
"the failed statement and earlier uncommitted work must be restored"
);
let mut closure = Database::open_memory();
closure.query("CREATE TABLE t (id)").unwrap();
closure.query("INSERT INTO t VALUES (1)").unwrap();
let error = closure
.transaction(|database| {
database.atomic_mutation(|database| {
database.insert_validated("t", vec![Value::Int(2)])?;
Err::<(), _>(PvError::Io(injected_io()))
})
})
.unwrap_err();
assert!(matches!(error, PvError::Io(_)));
assert_eq!(
closure.query("SELECT * FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(1)]]
);
}
#[test]
fn statement_preflight_error_keeps_explicit_transaction_active() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id PRIMARY KEY)").unwrap();
db.query("INSERT INTO t VALUES (1)").unwrap();
db.begin_transaction().unwrap();
let error = db.query("INSERT INTO t VALUES (2), (1), (3)").unwrap_err();
assert!(matches!(error, PvError::Schema(_)));
assert!(
db.in_transaction(),
"validation fails before the mutation rollback boundary"
);
assert_eq!(
db.query("SELECT * FROM t").unwrap().rows().unwrap(),
&[vec![Value::Int(1)]]
);
db.rollback_transaction().unwrap();
}
#[test]
fn unfinished_filesystem_transaction_recovers_on_open() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
{
let mut db = Database::open_dev(&ws).unwrap();
db.set_durability(Durability::Sync);
db.query("CREATE TABLE events (id PRIMARY KEY, state)")
.unwrap();
db.query("INSERT INTO events VALUES (1, 'committed')")
.unwrap();
db.begin_transaction().unwrap();
db.query("UPDATE events SET state = 'partial' WHERE id = 1")
.unwrap();
db.query("INSERT INTO events VALUES (2, 'partial')")
.unwrap();
db.flush_now().unwrap();
assert!(ws.join(TRANSACTION_MARKER_FILE).exists());
}
let mut recovered = Database::open_dev(&ws).unwrap();
let rows = recovered.query("SELECT * FROM events ORDER BY id").unwrap();
assert_eq!(
rows.rows().unwrap(),
&[vec![Value::Int(1), Value::Text("committed".into())]]
);
assert!(!ws.join(TRANSACTION_MARKER_FILE).exists());
assert!(!ws.join(TRANSACTION_BACKUP_DIR).exists());
}
#[test]
fn live_filesystem_transaction_cannot_be_mistaken_for_a_crash() {
let tmp = tempfile::tempdir().unwrap();
let ws = tmp.path().join("ws");
let mut owner = Database::open_dev(&ws).unwrap();
owner.query("CREATE TABLE t (id)").unwrap();
owner.begin_transaction().unwrap();
owner.query("INSERT INTO t VALUES (1)").unwrap();
assert!(matches!(
Database::open_dev(&ws),
Err(PvError::Transaction(_))
));
owner.rollback_transaction().unwrap();
assert!(Database::open_dev(&ws).is_ok());
}
#[test]
fn explicit_transactions_reject_invalid_lifecycle() {
let mut db = Database::open_memory();
assert!(matches!(
db.commit_transaction(),
Err(PvError::Transaction(_))
));
db.begin_transaction().unwrap();
assert!(matches!(
db.begin_transaction(),
Err(PvError::Transaction(_))
));
db.rollback_transaction().unwrap();
assert!(!db.in_transaction());
}
#[test]
fn update_limit_drop_and_count() {
let tmp = tempfile::tempdir().unwrap();
let mut db = Database::open_dev(tmp.path().join("ws")).unwrap();
db.query("CREATE TABLE t (id, status)").unwrap();
for i in 1..=5i64 {
db.query(&format!("INSERT INTO t VALUES ({i}, 'open')"))
.unwrap();
}
assert_eq!(db.row_count("t", None).unwrap(), 5);
assert_eq!(
db.query("UPDATE t SET status = 'closed' WHERE id = 3")
.unwrap(),
QueryResult::Mutated(1)
);
assert_eq!(db.row_count("t", None).unwrap(), 5);
let closed = db.query("SELECT * FROM t WHERE status = 'closed'").unwrap();
assert_eq!(closed.rows().unwrap().len(), 1);
assert_eq!(closed.rows().unwrap()[0][0], Value::Int(3));
assert_eq!(
db.query("SELECT * FROM t LIMIT 2")
.unwrap()
.rows()
.unwrap()
.len(),
2
);
db.query("DROP TABLE t").unwrap();
assert!(db.query("SELECT * FROM t").is_err());
}
#[test]
fn in_memory_database_works_and_exports() {
let mut db = Database::open_memory();
assert!(db.is_writable());
db.query("CREATE TABLE t (id, name)").unwrap();
db.query("INSERT INTO t VALUES (1, 'alice')").unwrap();
db.query("INSERT INTO t VALUES (2, 'bob')").unwrap();
db.query("CREATE INDEX ON t (name)").unwrap();
assert_eq!(
db.query("SELECT * FROM t").unwrap().rows().unwrap().len(),
2
);
assert_eq!(
db.query("SELECT * FROM t WHERE name = 'alice'")
.unwrap()
.rows()
.unwrap()
.len(),
1
);
assert_eq!(db.row_count("t", None).unwrap(), 2);
let bytes = db.bake_to_bytes().unwrap();
let tmp = tempfile::tempdir().unwrap();
let path = tmp.path().join("export.pvdb");
std::fs::write(&path, &bytes).unwrap();
let mut prod = Database::open_prod(&path).unwrap();
assert_eq!(
prod.query("SELECT * FROM t").unwrap().rows().unwrap().len(),
2
);
}
#[test]
fn import_bytes_round_trips_with_history_and_stays_writable() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, status)").unwrap();
db.query("INSERT INTO t VALUES (1, 'open')").unwrap();
db.query("INSERT INTO t VALUES (2, 'open')").unwrap();
let before = db.current_tx();
db.query("UPDATE t SET status = 'closed' WHERE id = 1")
.unwrap();
let bytes = db.bake_to_bytes().unwrap();
let mut db2 = Database::import_bytes(&bytes).unwrap();
assert!(db2.is_writable());
assert_eq!(
db2.query("SELECT * FROM t").unwrap().rows().unwrap().len(),
2
);
let past = db2
.query(&format!("SELECT * FROM t WHERE id = 1 BEFORE {before}"))
.unwrap();
assert_eq!(past.rows().unwrap()[0][1], Value::Text("open".into()));
db2.query("INSERT INTO t VALUES (3, 'open')").unwrap();
assert_eq!(
db2.query("SELECT * FROM t").unwrap().rows().unwrap().len(),
3
);
assert!(Database::import_bytes(&[0u8; 10]).is_err());
assert!(Database::import_bytes(&bytes[..bytes.len() / 2]).is_err());
}
#[test]
fn bounded_queries_stop_before_untrusted_work_grows_without_limit() {
let mut db = Database::open_memory();
db.query("CREATE TABLE t (id, body)").unwrap();
for id in 0..10 {
db.query(&format!("INSERT INTO t VALUES ({id}, 'payload')"))
.unwrap();
}
let scan_limited = QueryLimits::new(3, usize::MAX, usize::MAX, None);
assert!(matches!(
db.query_with_limits("SELECT * FROM t", &[], scan_limited),
Err(PvError::ResourceLimit(_))
));
let result_limited = QueryLimits::new(100, usize::MAX, 2, None);
assert!(matches!(
db.query_with_limits("SELECT * FROM t", &[], result_limited),
Err(PvError::ResourceLimit(_))
));
let expired = QueryLimits::new(100, usize::MAX, 100, Some(Instant::now()));
assert!(matches!(
db.query_with_limits("SELECT * FROM t", &[], expired),
Err(PvError::ResourceLimit(_))
));
let mutation_limited = QueryLimits::new(3, usize::MAX, 100, None);
assert!(matches!(
db.query_with_limits("DELETE FROM t WHERE id >= 0", &[], mutation_limited),
Err(PvError::ResourceLimit(_))
));
assert_eq!(db.row_count("t", None).unwrap(), 10);
}
#[test]
fn bounded_index_candidates_and_unique_update_scans_are_metered() {
let mut candidates = Database::open_memory();
candidates.query("CREATE TABLE hits (id, kind)").unwrap();
candidates
.query(
"INSERT INTO hits VALUES \
(1, 'same'), (2, 'same'), (3, 'same'), (4, 'same'), (5, 'same')",
)
.unwrap();
candidates.query("CREATE INDEX ON hits (kind)").unwrap();
let error = candidates
.query_with_limits(
"SELECT * FROM hits WHERE kind = 'same'",
&[],
QueryLimits::new(2, usize::MAX, usize::MAX, None),
)
.unwrap_err();
assert!(matches!(error, PvError::ResourceLimit(_)));
let mut unique = Database::open_memory();
unique
.query("CREATE TABLE guarded (id PRIMARY KEY, marker)")
.unwrap();
for id in 0..10 {
unique
.query(&format!("INSERT INTO guarded VALUES ({id}, {id})"))
.unwrap();
}
unique.query("CREATE INDEX ON guarded (marker)").unwrap();
unique
.query_with_limits(
"UPDATE guarded SET id = 100 WHERE marker = 0",
&[],
QueryLimits::new(3, usize::MAX, usize::MAX, None),
)
.unwrap();
assert_eq!(unique.row_count("guarded", None).unwrap(), 10);
assert_eq!(
unique
.query("SELECT id FROM guarded WHERE marker = 0")
.unwrap()
.rows()
.unwrap(),
&[vec![Value::Int(100)]]
);
}
}