use super::ivm_branch::IvmBranch;
use super::query_context::QueryContext;
use super::replica_store::KvWrite;
use super::{ApplicationError, Error};
use crate::ast::AggregateFunction;
use crate::builder::OptimisticAggregate;
use crate::hash::query::{hash_of_ast, hash_of_name_and_args};
use crate::ivm::{
MemorySource, Row, Source, SourceChange, ViewValue, aggregate_value, capture, group_key,
};
use crate::json::{Object, Value};
use crate::keys::{
aggregate_columns as cols, aggregate_row_key, got_queries_key, primary_key_string,
};
use crate::query::AnyQuery;
use crate::schema::{Schema, Table};
use std::cell::{OnceCell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use std::sync::Arc;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Reason {
Optimistic,
Rebase,
}
impl Reason {
pub fn as_str(self) -> &'static str {
match self {
Reason::Optimistic => "optimistic",
Reason::Rebase => "rebase",
}
}
}
pub struct Transaction {
client_id: String,
mutation_id: f64,
reason: Reason,
token: Option<String>,
pub(crate) write: RefCell<KvWrite>,
branch: Rc<IvmBranch>,
schema: Arc<Schema>,
pub(crate) rows: RefCell<HashMap<String, Row>>,
context: OnceCell<Rc<QueryContext>>,
synced_context: OnceCell<Rc<QueryContext>>,
}
impl Transaction {
pub(crate) fn new(
client_id: String,
mutation_id: f64,
reason: Reason,
token: Option<String>,
write: KvWrite,
branch: Rc<IvmBranch>,
schema: Arc<Schema>,
) -> Self {
Transaction {
client_id,
mutation_id,
reason,
token,
write: RefCell::new(write),
branch,
schema,
rows: RefCell::default(),
context: OnceCell::new(),
synced_context: OnceCell::new(),
}
}
pub(crate) fn finish(self) -> (KvWrite, HashMap<String, Row>) {
(self.write.into_inner(), self.rows.into_inner())
}
pub fn location(&self) -> &'static str {
"client"
}
pub fn client_id(&self) -> &str {
&self.client_id
}
pub fn mutation_id(&self) -> f64 {
self.mutation_id
}
pub fn reason(&self) -> Reason {
self.reason
}
pub fn token(&self) -> Option<&str> {
self.token.as_deref()
}
pub fn table<'a>(&'a self, table: &'a str) -> TableMutator<'a> {
TableMutator { tx: self, table }
}
pub fn run(&self, query: &AnyQuery) -> Result<ViewValue, Error> {
let query_id = match query.custom_query_id() {
Some(id) => hash_of_name_and_args(&id.name, &id.args),
None => hash_of_ast(query.ast()),
};
let synced = self.write.borrow().has(&got_queries_key(&query_id));
let context = if synced {
self.synced_context
.get_or_init(|| QueryContext::local(self.branch.clone(), true))
} else {
self.context
.get_or_init(|| QueryContext::local(self.branch.clone(), false))
};
context.snapshot(query)
}
fn table_schema(&self, table: &str) -> Result<&Table, Error> {
self.schema
.tables
.get(table)
.ok_or_else(|| ApplicationError::new(format!("Unknown table: {table}")).into())
}
fn key(table: &Table, value: &Object) -> Result<String, Error> {
Ok(primary_key_string(&table.name, &table.primary_key, value)?)
}
fn source(&self, table: &str) -> Rc<MemorySource> {
self.branch
.source(table)
.unwrap_or_else(|| panic!("No source for table {table}"))
}
fn push(source: &MemorySource, change: SourceChange) -> Result<(), Error> {
Ok(capture(|| source.push(change))?)
}
fn insert(&self, table_name: &str, value: &Object) -> Result<(), Error> {
let table = self.table_schema(table_name)?;
let key = Self::key(table, value)?;
if self.write.borrow().has(&key) {
return Ok(());
}
let mut row = value.clone();
for column in table.columns.keys() {
if !row.contains_key(column) {
row.insert(column.clone(), Value::Null);
}
}
self.branch.layouts.share(table_name, &mut row);
let row: Row = Rc::new(row);
self.write
.borrow_mut()
.set(&key, Value::Object((*row).clone()));
self.rows.borrow_mut().insert(key, row.clone());
Self::push(&self.source(table_name), SourceChange::Add(row.clone()))?;
self.apply_optimistic_aggregate_deltas(table_name, None, Some(&row))
}
fn upsert(&self, table_name: &str, value: &Object) -> Result<(), Error> {
let table = self.table_schema(table_name)?;
if self.write.borrow().has(&Self::key(table, value)?) {
self.update(table_name, value)
} else {
self.insert(table_name, value)
}
}
fn update(&self, table_name: &str, value: &Object) -> Result<(), Error> {
let table = self.table_schema(table_name)?;
let key = Self::key(table, value)?;
let Some(prev) = self
.write
.borrow()
.get(&key)
.and_then(|v| v.as_object().cloned())
else {
return Ok(());
};
let mut next = prev.clone();
for (k, v) in value.iter() {
next.insert(k.clone(), v.clone());
}
self.branch.layouts.share(table_name, &mut next);
self.write
.borrow_mut()
.set(&key, Value::Object(next.clone()));
let row: Row = Rc::new(next);
let old_row: Row = Rc::new(prev);
self.rows.borrow_mut().insert(key, row.clone());
Self::push(
&self.source(table_name),
SourceChange::Edit {
row: row.clone(),
old_row: old_row.clone(),
},
)?;
self.apply_optimistic_aggregate_deltas(table_name, Some(&old_row), Some(&row))
}
fn delete(&self, table_name: &str, id: &Object) -> Result<(), Error> {
let table = self.table_schema(table_name)?;
let key = Self::key(table, id)?;
let Some(prev) = self
.write
.borrow()
.get(&key)
.and_then(|v| v.as_object().cloned())
else {
return Ok(());
};
self.write.borrow_mut().delete(&key);
self.rows.borrow_mut().remove(&key);
let old_row: Row = Rc::new(prev);
Self::push(
&self.source(table_name),
SourceChange::Remove(old_row.clone()),
)?;
self.apply_optimistic_aggregate_deltas(table_name, Some(&old_row), None)
}
fn apply_optimistic_aggregate_deltas(
&self,
table: &str,
old: Option<&Row>,
new: Option<&Row>,
) -> Result<(), Error> {
for agg in self.branch.optimistic_aggregates(table) {
let old_key = old.map(|r| aggregate_key(&agg, r)).transpose()?.flatten();
let new_key = new.map(|r| aggregate_key(&agg, r)).transpose()?.flatten();
if old_key == new_key {
if let Some(k) = old_key {
self.apply_aggregate_delta(&agg, &k, old, new)?;
}
} else {
if let Some(k) = old_key {
self.apply_aggregate_delta(&agg, &k, old, None)?;
}
if let Some(k) = new_key {
self.apply_aggregate_delta(&agg, &k, None, new)?;
}
}
}
Ok(())
}
fn apply_aggregate_delta(
&self,
agg: &OptimisticAggregate,
key: &str,
old: Option<&Row>,
new: Option<&Row>,
) -> Result<(), Error> {
let source = self.branch.source(&agg.aggregate_table);
let cur = self
.write
.borrow()
.get(key)
.and_then(|v| v.as_object().cloned());
let Some(cur) = cur else {
if agg.grouped
&& let Some(added) = new_group_row(agg, old, new)
{
self.write
.borrow_mut()
.set(key, Value::Object(added.clone()));
if let Some(source) = &source {
Self::push(source, SourceChange::Add(Rc::new(added)))?;
}
}
return Ok(());
};
let Some(updated) = next_aggregate_row(agg, &cur, old, new) else {
return Ok(());
};
let cur_row: Row = Rc::new(cur);
let in_branch = source.as_ref().is_some_and(|s| s.contains(&cur_row));
if agg.grouped && group_row_count(agg, &updated) == Some(&Value::Number(0.0)) {
self.write.borrow_mut().delete(key);
if in_branch && let Some(source) = &source {
Self::push(source, SourceChange::Remove(cur_row))?;
}
return Ok(());
}
self.write
.borrow_mut()
.set(key, Value::Object(updated.clone()));
if in_branch && let Some(source) = &source {
Self::push(
source,
SourceChange::Edit {
row: Rc::new(updated),
old_row: cur_row,
},
)?;
}
Ok(())
}
}
fn aggregate_key(agg: &OptimisticAggregate, child: &Row) -> Result<Option<String>, Error> {
if agg.grouped {
let values: Vec<Value> = agg
.child_field
.iter()
.map(|c| child.get(c).cloned().unwrap_or(Value::Null))
.collect();
let mut row = Object::new();
row.insert(cols::KEY, Value::String(group_key(&values)));
return Ok(Some(aggregate_row_key(&agg.aggregate_table, &row)?));
}
let mut row = Object::new();
for (i, column) in agg.child_field.iter().enumerate() {
match child.get(column) {
None | Some(Value::Null) => return Ok(None),
Some(v) => {
row.insert(agg.key_field[i].clone(), v.clone());
}
}
}
Ok(Some(aggregate_row_key(&agg.aggregate_table, &row)?))
}
fn group_row_count<'a>(agg: &OptimisticAggregate, row: &'a Object) -> Option<&'a Value> {
row.get(if agg.aggregate.fn_ == AggregateFunction::Count {
cols::VALUE
} else {
cols::ROWS
})
}
fn counted(agg: &OptimisticAggregate, row: Option<&Row>) -> bool {
row.is_some_and(|r| agg.predicate.as_ref().is_none_or(|p| p(r)))
}
fn new_group_row(
agg: &OptimisticAggregate,
old: Option<&Row>,
new: Option<&Row>,
) -> Option<Object> {
if !counted(agg, new) || counted(agg, old) {
return None;
}
let new = new?;
let values: Vec<Value> = agg
.child_field
.iter()
.map(|c| new.get(c).cloned().unwrap_or(Value::Null))
.collect();
let mut empty = Object::new();
for (i, column) in agg.key_field.iter().enumerate() {
empty.insert(column.clone(), values[i].clone());
}
empty.insert(cols::KEY, Value::String(group_key(&values)));
if agg.aggregate.fn_ == AggregateFunction::Count {
empty.insert(cols::VALUE, Value::Number(0.0));
} else {
empty.insert(cols::VALUE, Value::Null);
empty.insert(cols::SUM, Value::Number(0.0));
empty.insert(cols::COUNT, Value::Number(0.0));
empty.insert(cols::ROWS, Value::Number(0.0));
}
next_aggregate_row(agg, &empty, None, Some(new))
}
fn number(v: Option<&Value>) -> f64 {
match v {
Some(Value::Number(n)) => *n,
_ => 0.0,
}
}
fn next_aggregate_row(
agg: &OptimisticAggregate,
cur: &Object,
old: Option<&Row>,
new: Option<&Row>,
) -> Option<Object> {
let passes = |r: &&Row| agg.predicate.as_ref().is_none_or(|p| p(r));
let old = old.filter(passes);
let new = new.filter(passes);
let contribution = |r: Option<&Row>| r.map(|r| aggregate_value(&agg.aggregate, r));
let contributes = |r: Option<&Row>| matches!(contribution(r), Some(Value::Number(_)));
let present = |r: Option<&Row>| if r.is_some() { 1.0 } else { 0.0 };
let mut next = cur.clone();
match agg.aggregate.fn_ {
AggregateFunction::Count => {
let delta = present(new) - present(old);
if delta == 0.0 {
return None;
}
next.insert(
cols::VALUE,
Value::Number(number(cur.get(cols::VALUE)) + delta),
);
Some(next)
}
AggregateFunction::Sum | AggregateFunction::Avg => {
agg.aggregate.field.as_ref()?;
let sum_delta = number(contribution(new).as_ref()) - number(contribution(old).as_ref());
let count_delta = (contributes(new) as u8 as f64) - (contributes(old) as u8 as f64);
let has_rows = cur.contains_key(cols::ROWS);
let rows_delta = if has_rows {
present(new) - present(old)
} else {
0.0
};
if sum_delta == 0.0 && count_delta == 0.0 && rows_delta == 0.0 {
return None;
}
let sum = number(cur.get(cols::SUM)) + sum_delta;
let count = number(cur.get(cols::COUNT)) + count_delta;
let result = if agg.aggregate.fn_ == AggregateFunction::Sum {
sum
} else {
sum / count
};
next.insert(
cols::VALUE,
if count > 0.0 {
Value::Number(result)
} else {
Value::Null
},
);
next.insert(cols::SUM, Value::Number(sum));
next.insert(cols::COUNT, Value::Number(count));
if has_rows {
next.insert(
cols::ROWS,
Value::Number(number(cur.get(cols::ROWS)) + rows_delta),
);
}
Some(next)
}
AggregateFunction::Min | AggregateFunction::Max => None,
}
}
pub struct TableMutator<'a> {
tx: &'a Transaction,
table: &'a str,
}
impl TableMutator<'_> {
pub fn insert(&self, value: &Object) -> Result<(), Error> {
self.tx.insert(self.table, value)
}
pub fn upsert(&self, value: &Object) -> Result<(), Error> {
self.tx.upsert(self.table, value)
}
pub fn update(&self, value: &Object) -> Result<(), Error> {
self.tx.update(self.table, value)
}
pub fn delete(&self, id: &Object) -> Result<(), Error> {
self.tx.delete(self.table, id)
}
}