Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

11.1 KB
Raw Blame
//! A view's query as the `SELECT` the engine runs, built without SQL text.

#[cfg(test)]
mod test;

use models_databases::TableId;
use models_databases::views::{
    Conjunction, DatabaseView, DateOperator, DateRangeOperator, FilterCondition, FilterGroup,
    FilterNode, FilterTest, NumberOperator, PresenceOperator, SetOperator, SortDirection,
    TextOperator, ViewLayout, ViewProblem, ViewQuery,
};

use crate::catalog::{Catalog, Column, Table};
use crate::resolve::{
    Binding, ComparisonOperator, Direction, Filter, Order, OrderKey, Relation, SelectItem,
    SelectQuery, Value, row_position_key,
};

use super::{checked_table, placed};

/// The escape character of the `LIKE` patterns text tests become.
const LIKE_ESCAPE: char = '\\';

/// The `SELECT * … WHERE … ORDER BY …, row_position` a view shows, exactly as
/// [`resolve`](crate::resolve::resolve) would bind it.
pub fn compile_view(view: &DatabaseView, catalog: &Catalog) -> Result<SelectQuery, ViewProblem> {
    compile_checked(view, checked_table(view, catalog)?)
}

/// Compile the filter and ordering of a table read, independent of its presentation.
pub fn compile_table_query(
    table_id: TableId,
    query: &ViewQuery,
    catalog: &Catalog,
) -> Result<SelectQuery, ViewProblem> {
    let table = catalog
        .tables
        .iter()
        .find(|table| table.id == table_id)
        .ok_or(ViewProblem::UnknownTable { table: table_id })?;
    let columns = table
        .columns
        .iter()
        .map(super::schema_column)
        .collect::<Vec<_>>();
    models_databases::views::check(query, &ViewLayout::Table { columns: vec![] }, &columns)?;
    compile_query_checked(query, table)
}

/// [`compile_view`] once the view has checked out against `table`.
pub(super) fn compile_checked(
    view: &DatabaseView,
    table: &Table,
) -> Result<SelectQuery, ViewProblem> {
    compile_query_checked(&view.query, table)
}

fn compile_query_checked(query: &ViewQuery, table: &Table) -> Result<SelectQuery, ViewProblem> {
    let position = row_position_key(table.id);
    let mut bindings: Vec<Binding> = table
        .columns
        .iter()
        .map(|column| Binding {
            key: column.id,
            relation: 0,
            column: Some(column.id),
        })
        .collect();
    bindings.push(Binding {
        key: position,
        relation: 0,
        column: None,
    });
    let order_by = query
        .sort
        .iter()
        .map(|key| {
            Ok(Order {
                key: OrderKey::Column(placed(table, key.column)?.id),
                direction: match key.direction {
                    SortDirection::Ascending => Direction::Ascending,
                    SortDirection::Descending => Direction::Descending,
                },
            })
        })
        .chain(std::iter::once(Ok(Order {
            key: OrderKey::Column(position),
            direction: Direction::Ascending,
        })))
        .collect::<Result<_, ViewProblem>>()?;
    let where_ = match &query.filter {
        Some(group) => group_filter(table, group)?,
        None => None,
    };
    Ok(SelectQuery {
        distinct: false,
        relations: vec![Relation {
            table: table.id,
            alias: table.name.clone(),
            source: table.source,
        }],
        joins: vec![],
        items: table
            .columns
            .iter()
            .map(|column| SelectItem::Column(column.id))
            .collect(),
        labels: vec![],
        where_,
        group_by: None,
        order_by,
        limit: None,
        offset: None,
        bindings,
    })
}

/// A group's filter; `None` when it keeps every row.
fn group_filter(table: &Table, group: &FilterGroup) -> Result<Option<Filter>, ViewProblem> {
    let mut parts = Vec::new();
    for node in &group.conditions {
        let part = match node {
            FilterNode::Condition(condition) => Some(condition_filter(table, condition)?),
            FilterNode::Group(group) => group_filter(table, group)?,
        };
        match (part, group.conjunction) {
            (Some(part), _) => parts.push(part),
            (None, Conjunction::And) => {}
            (None, Conjunction::Or) => return Ok(None),
        }
    }
    Ok(joined(group.conjunction, parts))
}

/// The parts under one conjunction: one part stands alone, none keeps every
/// row.
fn joined(conjunction: Conjunction, mut parts: Vec<Filter>) -> Option<Filter> {
    match (parts.len(), conjunction) {
        (0, _) => None,
        (1, _) => parts.pop(),
        (_, Conjunction::And) => Some(Filter::And(parts)),
        (_, Conjunction::Or) => Some(Filter::Or(parts)),
    }
}

fn condition_filter(table: &Table, condition: &FilterCondition) -> Result<Filter, ViewProblem> {
    let placed = placed(table, condition.column)?;
    let column = placed.id;
    let compare = |operator, value| Filter::Comparison {
        column,
        operator,
        value,
    };
    let or_empty = |filter| {
        Filter::Or(vec![
            filter,
            Filter::IsNull {
                column,
                negated: false,
            },
        ])
    };
    let like = |pattern, negated| Filter::Like {
        column,
        pattern,
        escape: Some(LIKE_ESCAPE),
        negated,
    };
    let filter = match &condition.test {
        FilterTest::Presence { operator } => Filter::IsNull {
            column,
            negated: *operator == PresenceOperator::IsNotEmpty,
        },
        FilterTest::Text { operator, value } => {
            let text = || Value::Text(value.clone());
            let literal = escaped(value);
            match operator {
                TextOperator::Is => compare(ComparisonOperator::Equal, text()),
                TextOperator::IsNot => or_empty(compare(ComparisonOperator::NotEqual, text())),
                TextOperator::Contains => like(format!("%{literal}%"), false),
                TextOperator::DoesNotContain => or_empty(like(format!("%{literal}%"), true)),
                TextOperator::StartsWith => like(format!("{literal}%"), false),
                TextOperator::EndsWith => like(format!("%{literal}"), false),
            }
        }
        FilterTest::Number { operator, value } => {
            let number = Value::Number(*value);
            match operator {
                NumberOperator::Is => compare(ComparisonOperator::Equal, number),
                NumberOperator::IsNot => or_empty(compare(ComparisonOperator::NotEqual, number)),
                NumberOperator::GreaterThan => compare(ComparisonOperator::Greater, number),
                NumberOperator::GreaterThanOrEqual => {
                    compare(ComparisonOperator::GreaterOrEqual, number)
                }
                NumberOperator::LessThan => compare(ComparisonOperator::Less, number),
                NumberOperator::LessThanOrEqual => compare(ComparisonOperator::LessOrEqual, number),
            }
        }
        FilterTest::Date { operator, value } => compare(
            match operator {
                DateOperator::Before => ComparisonOperator::Less,
                DateOperator::After => ComparisonOperator::Greater,
                DateOperator::OnOrBefore => ComparisonOperator::LessOrEqual,
                DateOperator::OnOrAfter => ComparisonOperator::GreaterOrEqual,
            },
            Value::Date(*value),
        ),
        // The test is of a whole day: a range compared to the day's first
        // instant tells whether it ends before it, and compared to its last
        // whether it starts after it.
        FilterTest::DateRange { operator, value } => {
            let first = Value::Date(*value);
            let last =
                Value::Date(*value + chrono::Duration::days(1) - chrono::Duration::microseconds(1));
            match operator {
                DateRangeOperator::Contains => Filter::And(vec![
                    compare(ComparisonOperator::GreaterOrEqual, first),
                    compare(ComparisonOperator::LessOrEqual, last),
                ]),
                DateRangeOperator::DoesNotContain => or_empty(Filter::Or(vec![
                    compare(ComparisonOperator::Less, first),
                    compare(ComparisonOperator::Greater, last),
                ])),
                DateRangeOperator::EndsBefore => compare(ComparisonOperator::Less, first),
                DateRangeOperator::EndsOnOrAfter => {
                    compare(ComparisonOperator::GreaterOrEqual, first)
                }
                DateRangeOperator::StartsAfter => compare(ComparisonOperator::Greater, last),
                DateRangeOperator::StartsOnOrBefore => {
                    compare(ComparisonOperator::LessOrEqual, last)
                }
            }
        }
        FilterTest::Checkbox { checked: true } => {
            compare(ComparisonOperator::Equal, Value::Bool(true))
        }
        FilterTest::Checkbox { checked: false } => {
            or_empty(compare(ComparisonOperator::Equal, Value::Bool(false)))
        }
        FilterTest::Options { operator, options } => set_filter(
            placed,
            *operator,
            options
                .iter()
                .map(|option| Value::Option(*option))
                .collect(),
        )?,
        FilterTest::Entities { operator, entities } => set_filter(
            placed,
            *operator,
            entities
                .iter()
                .map(|entity| Value::Entity(entity.clone()))
                .collect(),
        )?,
    };
    Ok(filter)
}

/// A set test. An absent multi-valued cell has no member, so `NOT HAS`
/// already keeps it; only `NOT IN` needs the empty cell named.
fn set_filter(
    placed: &Column,
    operator: SetOperator,
    values: Vec<Value>,
) -> Result<Filter, ViewProblem> {
    let column = placed.id;
    let has = |negated| {
        values
            .iter()
            .map(|value| Filter::Has {
                column,
                value: value.clone(),
                negated,
            })
            .collect::<Vec<_>>()
    };
    let members = match operator {
        SetOperator::IsAnyOf => {
            return Ok(Filter::In {
                column,
                values,
                negated: false,
            });
        }
        SetOperator::IsNoneOf => {
            return Ok(Filter::Or(vec![
                Filter::In {
                    column,
                    values,
                    negated: true,
                },
                Filter::IsNull {
                    column,
                    negated: false,
                },
            ]));
        }
        SetOperator::HasAny => joined(Conjunction::Or, has(false)),
        SetOperator::HasAll => joined(Conjunction::And, has(false)),
        SetOperator::HasNone => joined(Conjunction::And, has(true)),
    };
    members.ok_or_else(|| ViewProblem::NothingToMatch {
        column: placed.name.clone(),
    })
}

/// Text matched literally inside a `LIKE` pattern.
fn escaped(text: &str) -> String {
    let mut pattern = String::with_capacity(text.len());
    for character in text.chars() {
        if matches!(character, '%' | '_' | LIKE_ESCAPE) {
            pattern.push(LIKE_ESCAPE);
        }
        pattern.push(character);
    }
    pattern
}