use super::{Change, Comparator, Constraint, Node, NodeStream, PipelineError, Row, SourceChange};
use crate::ast::{Condition, OrderPart, System};
use crate::map::OrderedMap;
use crate::schema::{Column, Table};
use std::collections::HashSet;
use std::rc::{Rc, Weak};
#[derive(Clone)]
pub struct SourceSchema {
pub table_name: String,
pub columns: OrderedMap<Column>,
pub primary_key: Vec<String>,
pub relationships: Vec<(String, Rc<SourceSchema>)>,
pub is_hidden: bool,
pub system: System,
pub compare_rows: Comparator,
pub sort: Option<Vec<OrderPart>>,
}
impl SourceSchema {
pub fn relationship(&self, name: &str) -> Option<&Rc<SourceSchema>> {
self.relationships
.iter()
.find(|(n, _)| n == name)
.map(|(_, s)| s)
}
pub fn relationship_names(&self) -> Vec<&str> {
self.relationships.iter().map(|(n, _)| n.as_str()).collect()
}
pub fn adding(&self, name: &str, schema: Rc<SourceSchema>) -> SourceSchema {
let mut copy = self.clone();
match copy.relationships.iter_mut().find(|(n, _)| n == name) {
Some(entry) => entry.1 = schema,
None => copy.relationships.push((name.to_owned(), schema)),
}
copy
}
}
impl std::fmt::Debug for SourceSchema {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SourceSchema")
.field("table_name", &self.table_name)
.field("primary_key", &self.primary_key)
.field("relationships", &self.relationship_names())
.field("is_hidden", &self.is_hidden)
.field("system", &self.system)
.field("sort", &self.sort)
.finish()
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Basis {
At,
After,
}
#[derive(Clone, Debug)]
pub struct Start {
pub row: Row,
pub basis: Basis,
}
#[derive(Clone, Debug, Default)]
pub struct FetchRequest {
pub constraint: Option<Constraint>,
pub multi_constraints: Option<Vec<Vec<Constraint>>>,
pub start: Option<Start>,
pub reverse: bool,
pub filter: Option<Condition>,
}
pub trait InputBase {
fn get_schema(&self) -> Rc<SourceSchema>;
fn destroy(&self);
}
pub trait Input: InputBase {
fn set_output(&self, output: Weak<dyn Output>);
fn fetch(&self, req: &FetchRequest) -> NodeStream;
}
pub trait Output {
fn push(&self, change: Change, pusher: &dyn InputBase);
fn reconcile(&self, _pusher: &dyn InputBase) {}
}
pub trait Operator: Input + Output {}
impl<T: Input + Output> Operator for T {}
pub fn is_same(a: &dyn InputBase, b: &dyn InputBase) -> bool {
std::ptr::addr_eq(a, b)
}
pub fn no_output() -> Weak<dyn Output> {
Weak::<ClosureOutput>::new()
}
pub fn no_filter_output() -> Weak<dyn FilterOutput> {
Weak::<NoFilterOutput>::new()
}
pub struct NoFilterOutput;
impl Output for NoFilterOutput {
fn push(&self, _: Change, _: &dyn InputBase) {}
}
impl FilterOutput for NoFilterOutput {
fn begin_filter(&self) {}
fn filter(&self, _: &Node) -> bool {
false
}
fn end_filter(&self) {}
}
pub struct ClosureOutput {
on_push: Box<dyn Fn(Change)>,
on_reconcile: Box<dyn Fn()>,
}
impl ClosureOutput {
pub fn new(push: impl Fn(Change) + 'static, reconcile: impl Fn() + 'static) -> Rc<Self> {
Rc::new(ClosureOutput {
on_push: Box::new(push),
on_reconcile: Box::new(reconcile),
})
}
}
impl Output for ClosureOutput {
fn push(&self, change: Change, _pusher: &dyn InputBase) {
(self.on_push)(change)
}
fn reconcile(&self, _pusher: &dyn InputBase) {
(self.on_reconcile)()
}
}
pub trait FilterInput: InputBase {
fn set_filter_output(&self, output: Weak<dyn FilterOutput>);
}
pub trait FilterOutput: Output {
fn begin_filter(&self);
fn filter(&self, node: &Node) -> bool;
fn end_filter(&self);
}
pub trait FilterOperator: FilterInput + FilterOutput {}
impl<T: FilterInput + FilterOutput> FilterOperator for T {}
pub trait Source {
fn table_schema(&self) -> &Table;
fn connect(
&self,
sort: Option<Vec<OrderPart>>,
filters: Option<&Condition>,
split_edit_keys: Option<&HashSet<String>>,
) -> Result<Rc<dyn SourceInput>, PipelineError>;
fn push(&self, change: SourceChange);
}
pub trait SourceInput: Input {
fn fully_applied_filters(&self) -> bool;
}