cratestack-sql 0.14.0

Rust-native schema-first framework for typed HTTP APIs, generated clients, and backend services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! Relation-subquery constructors for [`FilterExpr`].
//!
//! Split from `expr.rs` (200-LoC ceiling): that module owns the enum
//! itself plus the boolean combinators (`all`/`any`/`not`/`and`/`or`),
//! this one owns the four `relation*` constructors, which are a
//! distinct concern — they build a correlated-subquery node rather
//! than combining existing predicates.
//!
//! Each constructor takes the related model's [`RelatedReadScope`] as a
//! required argument (GHSA-p55v-6xv5-93p3): pass
//! `<RELATED>_MODEL.related_read_scope()` so the subquery sees only the
//! related rows the caller could read, or [`RelatedReadScope::Unscoped`]
//! only when reading the raw related table is the point.

use cratestack_policy::RelationQuantifier;

use super::expr::{FilterExpr, RelationFilter};
use crate::RelatedReadScope;

impl FilterExpr {
    /// To-one: the related row exists, is visible under `scope`, and
    /// matches `filter`.
    pub fn relation(
        parent_table: &'static str,
        parent_column: &'static str,
        related_table: &'static str,
        related_column: &'static str,
        filter: FilterExpr,
        scope: RelatedReadScope,
    ) -> Self {
        Self::Relation(RelationFilter::new(
            RelationQuantifier::ToOne,
            parent_table,
            parent_column,
            related_table,
            related_column,
            filter,
            scope,
        ))
    }

    /// To-many `some`: at least one related row visible under `scope`
    /// matches `filter`.
    pub fn relation_some(
        parent_table: &'static str,
        parent_column: &'static str,
        related_table: &'static str,
        related_column: &'static str,
        filter: FilterExpr,
        scope: RelatedReadScope,
    ) -> Self {
        Self::Relation(RelationFilter::new(
            RelationQuantifier::Some,
            parent_table,
            parent_column,
            related_table,
            related_column,
            filter,
            scope,
        ))
    }

    /// To-many `every`: no related row visible under `scope` fails
    /// `filter` (vacuously true when none is visible).
    pub fn relation_every(
        parent_table: &'static str,
        parent_column: &'static str,
        related_table: &'static str,
        related_column: &'static str,
        filter: FilterExpr,
        scope: RelatedReadScope,
    ) -> Self {
        Self::Relation(RelationFilter::new(
            RelationQuantifier::Every,
            parent_table,
            parent_column,
            related_table,
            related_column,
            filter,
            scope,
        ))
    }

    /// To-many `none`: no related row visible under `scope` matches
    /// `filter`.
    pub fn relation_none(
        parent_table: &'static str,
        parent_column: &'static str,
        related_table: &'static str,
        related_column: &'static str,
        filter: FilterExpr,
        scope: RelatedReadScope,
    ) -> Self {
        Self::Relation(RelationFilter::new(
            RelationQuantifier::None,
            parent_table,
            parent_column,
            related_table,
            related_column,
            filter,
            scope,
        ))
    }
}