use std::collections::{BTreeMap, BTreeSet};
use std::fmt::{Debug, Formatter};
use std::iter;
use itertools::Itertools;
use miette::{Diagnostic, Result};
use thiserror::Error;
use crate::data::expr::{eval_bytecode, eval_bytecode_pred};
use crate::data::program::MagicSymbol;
use crate::data::symb::Symbol;
use crate::data::tuple::{Tuple, TupleIter};
use crate::parse::SourceSpan;
use crate::runtime::temp_store::EpochStore;
use crate::runtime::transact::SessionTx;
use super::{
eliminate_from_tuple, flatten_err, get_eliminate_indices, FilteredRA, InlineFixedRA,
RelAlgebra, ReorderRA, UnificationRA,
};
impl UnificationRA {
pub(super) fn fill_binding_indices_and_compile(&mut self) -> Result<()> {
let parent_bindings: BTreeMap<_, _> = self
.parent
.bindings_after_eliminate()
.into_iter()
.enumerate()
.map(|(a, b)| (b, a))
.collect();
self.expr.fill_binding_indices(&parent_bindings)?;
self.expr_bytecode = self.expr.compile()?;
Ok(())
}
pub(crate) fn do_eliminate_temp_vars(&mut self, used: &BTreeSet<Symbol>) -> Result<()> {
for binding in self.parent.bindings_before_eliminate() {
if !used.contains(&binding) {
self.to_eliminate.insert(binding.clone());
}
}
let mut nxt = used.clone();
nxt.extend(self.expr.bindings()?);
self.parent.eliminate_temp_vars(&nxt)?;
Ok(())
}
pub(super) fn iter<'a>(
&'a self,
tx: &'a SessionTx<'_>,
delta_rule: Option<&MagicSymbol>,
stores: &'a BTreeMap<MagicSymbol, EpochStore>,
) -> Result<TupleIter<'a>> {
let mut bindings = self.parent.bindings_after_eliminate();
bindings.push(self.binding.clone());
let eliminate_indices = get_eliminate_indices(&bindings, &self.to_eliminate);
let mut stack = vec![];
Ok(if self.is_multi {
let it = self
.parent
.iter(tx, delta_rule, stores)?
.map_ok(move |tuple| -> Result<Vec<Tuple>> {
let result_list = eval_bytecode(&self.expr_bytecode, &tuple, &mut stack)?;
let result_list = result_list.get_slice().ok_or_else(|| {
#[derive(Debug, Error, Diagnostic)]
#[error("Invalid spread unification")]
#[diagnostic(code(eval::invalid_spread_unif))]
#[diagnostic(help("Spread unification requires a list at the right"))]
struct BadSpreadUnification(#[label] SourceSpan);
BadSpreadUnification(self.span)
})?;
let mut coll = vec![];
for result in result_list {
let mut ret = tuple.clone();
ret.push(result.clone());
let ret = ret;
let ret = eliminate_from_tuple(ret, &eliminate_indices);
coll.push(ret);
}
Ok(coll)
})
.map(flatten_err)
.flatten_ok();
Box::new(it)
} else {
Box::new(
self.parent
.iter(tx, delta_rule, stores)?
.map_ok(move |tuple| -> Result<Tuple> {
let result = eval_bytecode(&self.expr_bytecode, &tuple, &mut stack)?;
let mut ret = tuple;
ret.push(result);
let ret = ret;
let ret = eliminate_from_tuple(ret, &eliminate_indices);
Ok(ret)
})
.map(flatten_err),
)
})
}
}
impl FilteredRA {
pub(crate) fn do_eliminate_temp_vars(&mut self, used: &BTreeSet<Symbol>) -> Result<()> {
for binding in self.parent.bindings_before_eliminate() {
if !used.contains(&binding) {
self.to_eliminate.insert(binding.clone());
}
}
let mut nxt = used.clone();
for e in self.filters.iter() {
nxt.extend(e.bindings()?);
}
self.parent.eliminate_temp_vars(&nxt)?;
Ok(())
}
pub(super) fn fill_binding_indices_and_compile(&mut self) -> Result<()> {
let parent_bindings: BTreeMap<_, _> = self
.parent
.bindings_after_eliminate()
.into_iter()
.enumerate()
.map(|(a, b)| (b, a))
.collect();
for e in self.filters.iter_mut() {
e.fill_binding_indices(&parent_bindings)?;
self.filters_bytecodes.push((e.compile()?, e.span()));
}
Ok(())
}
pub(super) fn iter<'a>(
&'a self,
tx: &'a SessionTx<'_>,
delta_rule: Option<&MagicSymbol>,
stores: &'a BTreeMap<MagicSymbol, EpochStore>,
) -> Result<TupleIter<'a>> {
let bindings = self.parent.bindings_after_eliminate();
let eliminate_indices = get_eliminate_indices(&bindings, &self.to_eliminate);
let mut stack = vec![];
Ok(Box::new(
self.parent
.iter(tx, delta_rule, stores)?
.filter_map(move |tuple| match tuple {
Ok(t) => {
for (p, span) in self.filters_bytecodes.iter() {
match eval_bytecode_pred(p, &t, &mut stack, *span) {
Ok(false) => return None,
Err(e) => return Some(Err(e)),
Ok(true) => {}
}
}
let t = eliminate_from_tuple(t, &eliminate_indices);
Some(Ok(t))
}
Err(e) => Some(Err(e)),
}),
))
}
}
pub(super) struct BindingFormatter(pub(super) Vec<Symbol>);
impl Debug for BindingFormatter {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
let s = self.0.iter().map(|f| f.to_string()).join(", ");
write!(f, "[{s}]")
}
}
impl Debug for RelAlgebra {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
let bindings = BindingFormatter(self.bindings_after_eliminate());
match self {
RelAlgebra::Fixed(r) => {
if r.bindings.is_empty() && r.data.len() == 1 {
f.write_str("Unit")
} else if r.data.len() == 1 {
f.debug_tuple("Singlet")
.field(&bindings)
.field(r.data.get(0).unwrap())
.finish()
} else {
f.debug_tuple("Fixed")
.field(&bindings)
.field(&["..."])
.finish()
}
}
RelAlgebra::TempStore(r) => f
.debug_tuple("TempStore")
.field(&bindings)
.field(&r.storage_key)
.field(&r.filters)
.finish(),
RelAlgebra::Stored(r) => f
.debug_tuple("Stored")
.field(&bindings)
.field(&r.storage.name)
.field(&r.filters)
.finish(),
RelAlgebra::HnswSearch(s) => f
.debug_tuple("HnswSearch")
.field(&bindings)
.field(&s.hnsw_search.idx_handle.name)
.finish(),
RelAlgebra::FtsSearch(s) => f
.debug_tuple("FtsSearch")
.field(&bindings)
.field(&s.fts_search.idx_handle.name)
.finish(),
RelAlgebra::LshSearch(s) => f
.debug_tuple("LshSearch")
.field(&bindings)
.field(&s.lsh_search.idx_handle.name)
.finish(),
RelAlgebra::StoredWithValidity(r) => f
.debug_tuple("StoredWithValidity")
.field(&bindings)
.field(&r.storage.name)
.field(&r.filters)
.field(&r.valid_at)
.finish(),
RelAlgebra::Join(r) => {
if r.left.is_unit() {
r.right.fmt(f)
} else {
f.debug_tuple("Join")
.field(&bindings)
.field(&r.joiner)
.field(&r.left)
.field(&r.right)
.finish()
}
}
RelAlgebra::NegJoin(r) => f
.debug_tuple("NegJoin")
.field(&bindings)
.field(&r.joiner)
.field(&r.left)
.field(&r.right)
.finish(),
RelAlgebra::Reorder(r) => f
.debug_tuple("Reorder")
.field(&r.new_order)
.field(&r.relation)
.finish(),
RelAlgebra::Filter(r) => f
.debug_tuple("Filter")
.field(&bindings)
.field(&r.filters)
.field(&r.parent)
.finish(),
RelAlgebra::Unification(r) => f
.debug_tuple("Unify")
.field(&bindings)
.field(&r.parent)
.field(&r.binding)
.field(&r.expr)
.finish(),
}
}
}
impl ReorderRA {
pub(super) fn bindings(&self) -> Vec<Symbol> {
self.new_order.clone()
}
pub(super) fn iter<'a>(
&'a self,
tx: &'a SessionTx<'_>,
delta_rule: Option<&MagicSymbol>,
stores: &'a BTreeMap<MagicSymbol, EpochStore>,
) -> Result<TupleIter<'a>> {
let old_order = self.relation.bindings_after_eliminate();
let old_order_indices: BTreeMap<_, _> = old_order
.into_iter()
.enumerate()
.map(|(k, v)| (v, k))
.collect();
let reorder_indices = self
.new_order
.iter()
.map(|k| {
*old_order_indices
.get(k)
.expect("program logic error: reorder indices mismatch")
})
.collect_vec();
Ok(Box::new(
self.relation
.iter(tx, delta_rule, stores)?
.map_ok(move |tuple| {
let old = tuple;
let new = reorder_indices
.iter()
.map(|i| old[*i].clone())
.collect_vec();
new
}),
))
}
}
impl InlineFixedRA {
pub(crate) fn unit(span: SourceSpan) -> Self {
Self {
bindings: vec![],
data: vec![vec![]],
to_eliminate: Default::default(),
span,
}
}
pub(crate) fn do_eliminate_temp_vars(&mut self, used: &BTreeSet<Symbol>) -> Result<()> {
for binding in &self.bindings {
if !used.contains(binding) {
self.to_eliminate.insert(binding.clone());
}
}
Ok(())
}
}
impl InlineFixedRA {
pub(crate) fn join_type(&self) -> &str {
if self.data.is_empty() {
"null_join"
} else if self.data.len() == 1 {
"singleton_join"
} else {
"fixed_join"
}
}
pub(crate) fn join<'a>(
&'a self,
left_iter: TupleIter<'a>,
(left_join_indices, right_join_indices): (Vec<usize>, Vec<usize>),
eliminate_indices: BTreeSet<usize>,
) -> Result<TupleIter<'a>> {
Ok(if self.data.is_empty() {
Box::new(iter::empty())
} else if self.data.len() == 1 {
let data = self.data[0].clone();
let right_join_values = right_join_indices
.into_iter()
.map(|v| data[v].clone())
.collect_vec();
Box::new(left_iter.filter_map_ok(move |tuple| {
let left_join_values = left_join_indices.iter().map(|v| &tuple[*v]).collect_vec();
if left_join_values.into_iter().eq(right_join_values.iter()) {
let mut ret = tuple;
ret.extend_from_slice(&data);
let ret = ret;
let ret = eliminate_from_tuple(ret, &eliminate_indices);
Some(ret)
} else {
None
}
}))
} else {
let mut right_mapping = BTreeMap::new();
for data in &self.data {
let right_join_values = right_join_indices.iter().map(|v| &data[*v]).collect_vec();
match right_mapping.get_mut(&right_join_values) {
None => {
right_mapping.insert(right_join_values, vec![data]);
}
Some(coll) => {
coll.push(data);
}
}
}
Box::new(
left_iter
.filter_map_ok(move |tuple| {
let left_join_values =
left_join_indices.iter().map(|v| &tuple[*v]).collect_vec();
right_mapping.get(&left_join_values).map(|v| {
v.iter()
.map(|right_values| {
let mut left_data = tuple.clone();
left_data.extend_from_slice(right_values);
left_data
})
.collect_vec()
})
})
.flatten_ok(),
)
})
}
}