Skip to main content

che_orm/
query.rs

1use std::collections::HashSet;
2use std::marker::PhantomData;
3
4use crate::{
5    ColumnRef, CompareOp, CreateTableQuery, DatabaseValue, Expr, ModelField, QueryValue, TableRef,
6    TableSchema,
7};
8
9#[derive(Debug, Clone, Copy)]
10pub enum OrderDirection {
11    Asc,
12    Desc,
13}
14
15#[derive(Debug, Clone, Copy)]
16pub struct OrderBy {
17    pub column: ColumnRef,
18    pub direction: OrderDirection,
19}
20
21#[derive(Debug, Clone, Copy)]
22pub struct JoinedField<T> {
23    column: ColumnRef,
24    _marker: PhantomData<T>,
25}
26
27impl<T> JoinedField<T> {
28    pub const fn new(column: ColumnRef) -> Self {
29        Self {
30            column,
31            _marker: PhantomData,
32        }
33    }
34
35    fn comparison<V>(self, op: CompareOp, value: V) -> Expr
36    where
37        V: QueryValue<T>,
38    {
39        Expr::Compare {
40            left: Box::new(Expr::Column(self.column)),
41            op,
42            right: Box::new(Expr::Value(value.into_query_value())),
43        }
44    }
45
46    pub fn eq<V>(self, value: V) -> Expr
47    where
48        V: QueryValue<T>,
49    {
50        self.comparison(CompareOp::Eq, value)
51    }
52
53    pub fn ne<V>(self, value: V) -> Expr
54    where
55        V: QueryValue<T>,
56    {
57        self.comparison(CompareOp::Ne, value)
58    }
59
60    pub fn gt<V>(self, value: V) -> Expr
61    where
62        V: QueryValue<T>,
63    {
64        self.comparison(CompareOp::Gt, value)
65    }
66
67    pub fn gte<V>(self, value: V) -> Expr
68    where
69        V: QueryValue<T>,
70    {
71        self.comparison(CompareOp::Gte, value)
72    }
73
74    pub fn lt<V>(self, value: V) -> Expr
75    where
76        V: QueryValue<T>,
77    {
78        self.comparison(CompareOp::Lt, value)
79    }
80
81    pub fn lte<V>(self, value: V) -> Expr
82    where
83        V: QueryValue<T>,
84    {
85        self.comparison(CompareOp::Lte, value)
86    }
87
88    pub fn is_null(self) -> Expr {
89        Expr::IsNull(Box::new(Expr::Column(self.column)))
90    }
91
92    pub fn is_not_null(self) -> Expr {
93        Expr::IsNotNull(Box::new(Expr::Column(self.column)))
94    }
95
96    pub const fn asc(self) -> OrderBy {
97        OrderBy {
98            column: self.column,
99            direction: OrderDirection::Asc,
100        }
101    }
102
103    pub const fn desc(self) -> OrderBy {
104        OrderBy {
105            column: self.column,
106            direction: OrderDirection::Desc,
107        }
108    }
109}
110
111#[derive(Debug, Clone)]
112pub struct SelectAst {
113    pub table: TableRef,
114    pub columns: Vec<ColumnRef>,
115    pub joins: Vec<JoinAst>,
116    pub filter: Option<Expr>,
117    pub order_by: Vec<OrderBy>,
118    pub limit: Option<u64>,
119    pub offset: Option<u64>,
120}
121
122#[derive(Debug, Clone)]
123pub struct JoinAst {
124    pub table: TableRef,
125    pub alias: &'static str,
126    pub kind: JoinType,
127    pub on: Expr,
128}
129
130#[derive(Debug, Clone, Copy)]
131pub enum JoinType {
132    Inner,
133    Left,
134}
135
136#[derive(Debug, Clone)]
137pub struct InsertValue {
138    pub column: ColumnRef,
139    pub value: DatabaseValue,
140}
141
142#[derive(Debug, Clone)]
143pub struct InsertAst {
144    pub table: TableRef,
145    pub values: Vec<InsertValue>,
146    pub returning: Vec<ColumnRef>,
147}
148
149#[derive(Debug, Clone)]
150pub struct Assignment {
151    pub column: ColumnRef,
152    pub value: DatabaseValue,
153}
154
155#[derive(Debug, Clone)]
156pub struct UpdateAst {
157    pub table: TableRef,
158    pub assignments: Vec<Assignment>,
159    pub filter: Option<Expr>,
160    pub returning: Vec<ColumnRef>,
161    pub allow_all: bool,
162}
163
164#[derive(Debug, Clone)]
165pub struct DeleteAst {
166    pub table: TableRef,
167    pub filter: Option<Expr>,
168    pub allow_all: bool,
169}
170
171#[derive(Debug, Clone)]
172pub enum QueryAst {
173    Select(SelectAst),
174    Insert(InsertAst),
175    Update(UpdateAst),
176    Delete(DeleteAst),
177    CreateTable(crate::CreateTableAst),
178}
179
180#[derive(Debug, Clone, PartialEq, Eq)]
181/// Errors detected while finalizing a query builder.
182pub enum QueryBuildError {
183    EmptyUpdate,
184    PrimaryKeyUpdate,
185    MissingFilter,
186    DuplicateColumn(&'static str),
187    ForeignTableColumn {
188        column: &'static str,
189        table: &'static str,
190        expected_table: &'static str,
191    },
192    InvalidSchema(String),
193}
194
195impl QueryAst {
196    /// Validates a query before it is sent to a database.
197    pub fn validate(&self) -> Result<(), QueryBuildError> {
198        match self {
199            Self::Select(query) => {
200                let mut tables = vec![query.table.name];
201                for join in &query.joins {
202                    tables.extend([join.table.name, join.alias]);
203                }
204                validate_expr_tables(query.filter.as_ref(), &tables)?;
205                for join in &query.joins {
206                    validate_expr_tables(Some(&join.on), &tables)?;
207                }
208                for order in &query.order_by {
209                    validate_expr_tables(Some(&Expr::Column(order.column)), &tables)?;
210                }
211                Ok(())
212            }
213            Self::Insert(query) => {
214                validate_unique_columns(query.values.iter().map(|value| &value.column))?;
215                validate_columns_table(
216                    query.table.name,
217                    query.values.iter().map(|value| &value.column),
218                )
219            }
220            Self::Update(query) => {
221                if query.assignments.is_empty() {
222                    return Err(QueryBuildError::EmptyUpdate);
223                }
224                if query.filter.is_none() && !query.allow_all {
225                    return Err(QueryBuildError::MissingFilter);
226                }
227                validate_unique_columns(
228                    query
229                        .assignments
230                        .iter()
231                        .map(|assignment| &assignment.column),
232                )?;
233                validate_columns_table(
234                    query.table.name,
235                    query
236                        .assignments
237                        .iter()
238                        .map(|assignment| &assignment.column),
239                )?;
240                validate_expr_table(query.filter.as_ref(), query.table.name)
241            }
242            Self::Delete(query) => {
243                if query.filter.is_none() && !query.allow_all {
244                    return Err(QueryBuildError::MissingFilter);
245                }
246                validate_expr_table(query.filter.as_ref(), query.table.name)
247            }
248            Self::CreateTable(query) => query
249                .schema
250                .validate()
251                .map_err(|error| QueryBuildError::InvalidSchema(format!("{error:?}"))),
252        }
253    }
254}
255
256/// Trait implemented by `#[derive(Model)]` for ORM models.
257pub trait Model: Sized {
258    type PrimaryKey: crate::PrimaryKey;
259    /// Stable Rust model name used by migration state. It is deliberately
260    /// independent from `table_name()` so table renames keep model identity.
261    fn model_name() -> &'static str {
262        std::any::type_name::<Self>()
263            .rsplit("::")
264            .next()
265            .unwrap_or("Model")
266    }
267    fn table_name() -> &'static str;
268    fn columns() -> &'static [&'static str];
269    /// Returns the model's typed primary-key field.
270    fn primary_key() -> ModelField<Self, Self::PrimaryKey>;
271    fn primary_key_value(&self) -> Self::PrimaryKey;
272    fn schema() -> TableSchema;
273    fn from_row(row: &crate::Row) -> Result<Self, crate::DecodeError>;
274    fn from_row_at(row: &crate::Row, offset: usize) -> Result<Self, crate::DecodeError> {
275        if offset == 0 {
276            Self::from_row(row)
277        } else {
278            Err(crate::DecodeError::InvalidColumnIndex(offset))
279        }
280    }
281    /// Adapter for direct SQLite driver queries.
282    #[cfg(feature = "sqlite")]
283    fn from_sqlite_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<Self> {
284        Self::from_row(&crate::Row::from_sqlite(row)?).map_err(|error| {
285            rusqlite::Error::FromSqlConversionFailure(
286                0,
287                rusqlite::types::Type::Null,
288                Box::new(error),
289            )
290        })
291    }
292    fn insert_values(&self) -> Vec<InsertValue>;
293    /// Physical columns that must not accept untrusted write values. The derive
294    /// includes `ImageField` and `Option<ImageField>`; trusted ORM writes remain
295    /// available for validated uploads. External write adapters enforce this
296    /// metadata, just as ModelSerializer enforces image read-only behavior.
297    fn write_protected_columns() -> &'static [&'static str] {
298        &[]
299    }
300    /// TEXT-backed JSON columns retain their JSON type in external codecs.
301    fn json_columns() -> &'static [&'static str] {
302        &[]
303    }
304    /// Materialized field values keyed by physical SQL column, independently of
305    /// Serde naming. Unlike insert values, these include generated keys and
306    /// managed timestamps. The derive generates a complete implementation;
307    /// manual models with managed fields should override this method.
308    fn field_values(&self) -> Vec<InsertValue> {
309        let mut values = self.insert_values();
310        let column = Self::primary_key().column();
311        if !values.iter().any(|value| value.column == column) {
312            values.push(InsertValue {
313                column,
314                value: self.primary_key_value().into_query_value(),
315            });
316        }
317        values
318    }
319    fn managed_update_values() -> Vec<Assignment> {
320        Vec::new()
321    }
322    fn query() -> SelectQuery<Self> {
323        SelectQuery::new()
324    }
325    fn insert() -> InsertQuery<Self> {
326        InsertQuery::new()
327    }
328    fn update() -> UpdateQuery<Self> {
329        UpdateQuery::new()
330    }
331    fn delete() -> DeleteQuery<Self> {
332        DeleteQuery::new()
333    }
334    fn create_table() -> CreateTableQuery<Self> {
335        CreateTableQuery::new(Self::schema())
336    }
337}
338
339/// Converts a materialized ORM model into an API representation.
340pub trait ModelSerializer: serde::Serialize + Sized {
341    type Model: Model;
342    type Input;
343
344    fn from_input(input: Self::Input) -> Self;
345
346    fn to_json(input: Self::Input) -> Result<serde_json::Value, serde_json::Error> {
347        serde_json::to_value(Self::from_input(input))
348    }
349
350    fn fields() -> &'static [SerializerField] {
351        &[]
352    }
353}
354
355/// Identifies the actual foreign-key column behind a serializer relation.
356pub trait RelationSource {
357    const SOURCE: &'static str;
358}
359
360#[derive(Debug, Clone, Copy, PartialEq, Eq)]
361pub struct SerializerField {
362    pub name: &'static str,
363    pub source: &'static str,
364    pub read_only: bool,
365    pub write_only: bool,
366    pub rust_type: &'static str,
367    pub related_model: Option<&'static str>,
368    pub many: bool,
369}
370
371/// A typed forward foreign-key relation from one model to another.
372#[derive(Debug, Clone, Copy)]
373pub struct BelongsTo<From, To, Relation = (), Key = i64> {
374    field: ColumnRef,
375    getter: fn(&From) -> Key,
376    alias: &'static str,
377    related_name: &'static str,
378    _marker: PhantomData<fn() -> (From, To, Relation, Key)>,
379}
380
381impl<From, To, Relation, Key> BelongsTo<From, To, Relation, Key> {
382    pub const fn new(
383        table: &'static str,
384        column: &'static str,
385        getter: fn(&From) -> Key,
386        alias: &'static str,
387        related_name: &'static str,
388    ) -> Self {
389        Self {
390            field: ColumnRef::new(table, column),
391            getter,
392            alias,
393            related_name,
394            _marker: PhantomData,
395        }
396    }
397
398    pub const fn field(&self) -> ColumnRef {
399        self.field
400    }
401
402    pub const fn alias(&self) -> &'static str {
403        self.alias
404    }
405
406    pub const fn related_field<T>(&self, field: ModelField<To, T>) -> JoinedField<T> {
407        JoinedField::new(ColumnRef {
408            table: self.alias,
409            ..field.column()
410        })
411    }
412
413    pub fn foreign_key(&self, model: &From) -> Key {
414        (self.getter)(model)
415    }
416
417    pub const fn reverse(&self) -> HasMany<To, From, Relation, Key> {
418        HasMany {
419            field: self.field,
420            getter: self.getter,
421            related_name: self.related_name,
422            _marker: PhantomData,
423        }
424    }
425}
426
427/// A typed reverse foreign-key relation from one model to many related models.
428#[derive(Debug, Clone, Copy)]
429pub struct HasMany<From, To, Relation = (), Key = i64> {
430    field: ColumnRef,
431    getter: fn(&To) -> Key,
432    related_name: &'static str,
433    _marker: PhantomData<fn() -> (From, To, Relation, Key)>,
434}
435
436impl<From, To, Relation, Key> HasMany<From, To, Relation, Key> {
437    pub const fn field(&self) -> ColumnRef {
438        self.field
439    }
440
441    pub fn foreign_key(&self, model: &To) -> Key {
442        (self.getter)(model)
443    }
444
445    pub const fn related_name(&self) -> &'static str {
446        self.related_name
447    }
448}
449
450pub struct SelectQuery<M> {
451    ast: SelectAst,
452    _model: PhantomData<M>,
453}
454
455impl<M: Model> SelectQuery<M> {
456    pub fn new() -> Self {
457        let table = M::table_name();
458        let columns = M::columns()
459            .iter()
460            .map(|column| ColumnRef::new(table, column))
461            .collect();
462        Self {
463            ast: SelectAst {
464                table: TableRef::new(table),
465                columns,
466                joins: Vec::new(),
467                filter: None,
468                order_by: Vec::new(),
469                limit: None,
470                offset: None,
471            },
472            _model: PhantomData,
473        }
474    }
475    pub fn filter(mut self, expr: Expr) -> Self {
476        self.ast.filter = Some(
477            self.ast
478                .filter
479                .map_or(expr.clone(), |previous| previous.and(expr)),
480        );
481        self
482    }
483    pub fn order_by(mut self, order: OrderBy) -> Self {
484        self.ast.order_by.push(order);
485        self
486    }
487    pub fn limit(mut self, limit: u64) -> Self {
488        self.ast.limit = Some(limit);
489        self
490    }
491    pub fn offset(mut self, offset: u64) -> Self {
492        self.ast.offset = Some(offset);
493        self
494    }
495    pub fn into_ast(self) -> Result<QueryAst, QueryBuildError> {
496        let mut tables = vec![self.ast.table.name];
497        for join in &self.ast.joins {
498            tables.push(join.table.name);
499            tables.push(join.alias);
500        }
501        validate_expr_tables(self.ast.filter.as_ref(), &tables)?;
502        for join in &self.ast.joins {
503            validate_expr_tables(Some(&join.on), &tables)?;
504        }
505        Ok(QueryAst::Select(self.ast))
506    }
507
508    pub(crate) fn into_select_ast(self) -> Result<SelectAst, QueryBuildError> {
509        match self.into_ast()? {
510            QueryAst::Select(select) => Ok(select),
511            _ => unreachable!(),
512        }
513    }
514
515    pub fn into_joined_ast<R: Model, Relation, Key>(
516        self,
517        relation: BelongsTo<M, R, Relation, Key>,
518    ) -> Result<QueryAst, QueryBuildError> {
519        self.into_joined_ast_with_kind(relation, JoinType::Inner)
520    }
521
522    pub fn into_optional_joined_ast<R: Model, Relation, Key>(
523        self,
524        relation: BelongsTo<M, R, Relation, Option<Key>>,
525    ) -> Result<QueryAst, QueryBuildError> {
526        self.into_joined_ast_with_kind(relation, JoinType::Left)
527    }
528
529    pub(crate) fn into_joined_ast_with_kind<R: Model, Relation, Key>(
530        mut self,
531        relation: BelongsTo<M, R, Relation, Key>,
532        kind: JoinType,
533    ) -> Result<QueryAst, QueryBuildError> {
534        self.ast.columns.extend(
535            R::columns()
536                .iter()
537                .map(|column| ColumnRef::new(relation.alias(), column)),
538        );
539        self.ast.joins.push(JoinAst {
540            table: TableRef::new(R::table_name()),
541            alias: relation.alias(),
542            kind,
543            on: Expr::Compare {
544                left: Box::new(Expr::Column(relation.field())),
545                op: CompareOp::Eq,
546                right: Box::new(Expr::Column(ColumnRef::new(
547                    relation.alias(),
548                    R::primary_key().column().name,
549                ))),
550            },
551        });
552        self.into_ast()
553    }
554}
555
556pub struct InsertQuery<M> {
557    ast: InsertAst,
558    _model: PhantomData<M>,
559}
560
561impl<M: Model> InsertQuery<M> {
562    pub fn new() -> Self {
563        Self {
564            ast: InsertAst {
565                table: TableRef::new(M::table_name()),
566                values: Vec::new(),
567                returning: Vec::new(),
568            },
569            _model: PhantomData,
570        }
571    }
572    pub fn set<T, V>(mut self, field: ModelField<M, T>, value: V) -> Self
573    where
574        V: QueryValue<T>,
575    {
576        self.ast.values.push(InsertValue {
577            column: field.column(),
578            value: value.into_query_value(),
579        });
580        self
581    }
582    pub fn returning_all(mut self) -> Self {
583        self.ast.returning = M::columns()
584            .iter()
585            .map(|column| ColumnRef::new(M::table_name(), column))
586            .collect();
587        self
588    }
589    pub fn into_ast(mut self) -> Result<QueryAst, QueryBuildError> {
590        let column = M::primary_key().column();
591        if !self.ast.values.iter().any(|value| value.column == column)
592            && let Some(value) = <M::PrimaryKey as crate::PrimaryKey>::generated_value()
593        {
594            self.ast.values.push(InsertValue { column, value });
595        }
596        validate_unique_columns(self.ast.values.iter().map(|value| &value.column))?;
597        Ok(QueryAst::Insert(self.ast))
598    }
599}
600
601pub struct UpdateQuery<M> {
602    ast: UpdateAst,
603    allow_all: bool,
604    _model: PhantomData<M>,
605}
606
607impl<M: Model> UpdateQuery<M> {
608    pub(crate) fn from_model(model: &M) -> Self {
609        let schema = M::schema();
610        let mut query = Self::new().filter(M::primary_key().eq(model.primary_key_value()));
611        query.ast.assignments = model
612            .field_values()
613            .into_iter()
614            .filter(|value| {
615                !schema.columns.iter().any(|column| {
616                    column.name == value.column.name
617                        && (column.primary_key || column.auto_now_add || column.auto_now)
618                })
619            })
620            .map(|value| Assignment {
621                column: value.column,
622                value: value.value,
623            })
624            .collect();
625        query
626    }
627
628    pub fn new() -> Self {
629        Self {
630            ast: UpdateAst {
631                table: TableRef::new(M::table_name()),
632                assignments: Vec::new(),
633                filter: None,
634                returning: Vec::new(),
635                allow_all: false,
636            },
637            allow_all: false,
638            _model: PhantomData,
639        }
640    }
641    pub fn set<T, V>(mut self, field: ModelField<M, T>, value: V) -> Self
642    where
643        V: QueryValue<T>,
644    {
645        self.ast.assignments.push(Assignment {
646            column: field.column(),
647            value: value.into_query_value(),
648        });
649        self
650    }
651    pub fn filter(mut self, expr: Expr) -> Self {
652        self.ast.filter = Some(
653            self.ast
654                .filter
655                .map_or(expr.clone(), |previous| previous.and(expr)),
656        );
657        self
658    }
659    pub fn returning_all(mut self) -> Self {
660        self.ast.returning = M::columns()
661            .iter()
662            .map(|column| ColumnRef::new(M::table_name(), column))
663            .collect();
664        self
665    }
666    pub fn allow_all(mut self) -> Self {
667        self.allow_all = true;
668        self
669    }
670    pub fn into_ast(mut self) -> Result<QueryAst, QueryBuildError> {
671        for managed in M::managed_update_values() {
672            self.ast
673                .assignments
674                .retain(|assignment| assignment.column.name != managed.column.name);
675            self.ast.assignments.push(managed);
676        }
677        if self.ast.assignments.is_empty() {
678            return Err(QueryBuildError::EmptyUpdate);
679        }
680        if self.ast.filter.is_none() && !self.allow_all {
681            return Err(QueryBuildError::MissingFilter);
682        }
683        let primary_key = M::primary_key().column();
684        if self
685            .ast
686            .assignments
687            .iter()
688            .any(|assignment| assignment.column == primary_key)
689        {
690            return Err(QueryBuildError::PrimaryKeyUpdate);
691        }
692        validate_unique_columns(
693            self.ast
694                .assignments
695                .iter()
696                .map(|assignment| &assignment.column),
697        )?;
698        validate_expr_table(self.ast.filter.as_ref(), self.ast.table.name)?;
699        self.ast.allow_all = self.allow_all;
700        Ok(QueryAst::Update(self.ast))
701    }
702}
703
704pub struct DeleteQuery<M> {
705    ast: DeleteAst,
706    allow_all: bool,
707    _model: PhantomData<M>,
708}
709
710impl<M: Model> DeleteQuery<M> {
711    pub fn new() -> Self {
712        Self {
713            ast: DeleteAst {
714                table: TableRef::new(M::table_name()),
715                filter: None,
716                allow_all: false,
717            },
718            allow_all: false,
719            _model: PhantomData,
720        }
721    }
722    pub fn filter(mut self, expr: Expr) -> Self {
723        self.ast.filter = Some(
724            self.ast
725                .filter
726                .map_or(expr.clone(), |previous| previous.and(expr)),
727        );
728        self
729    }
730    pub fn allow_all(mut self) -> Self {
731        self.allow_all = true;
732        self
733    }
734    pub fn into_ast(mut self) -> Result<QueryAst, QueryBuildError> {
735        if self.ast.filter.is_none() && !self.allow_all {
736            return Err(QueryBuildError::MissingFilter);
737        }
738        validate_expr_table(self.ast.filter.as_ref(), self.ast.table.name)?;
739        self.ast.allow_all = self.allow_all;
740        Ok(QueryAst::Delete(self.ast))
741    }
742}
743
744fn validate_unique_columns<'a>(
745    columns: impl Iterator<Item = &'a ColumnRef>,
746) -> Result<(), QueryBuildError> {
747    let mut names = HashSet::new();
748    for column in columns {
749        if !names.insert(column.name) {
750            return Err(QueryBuildError::DuplicateColumn(column.name));
751        }
752    }
753    Ok(())
754}
755
756fn validate_columns_table<'a>(
757    table: &'static str,
758    columns: impl Iterator<Item = &'a ColumnRef>,
759) -> Result<(), QueryBuildError> {
760    for column in columns {
761        validate_column_table(column, table)?;
762    }
763    Ok(())
764}
765
766fn validate_expr_table(expr: Option<&Expr>, table: &'static str) -> Result<(), QueryBuildError> {
767    let Some(expr) = expr else {
768        return Ok(());
769    };
770    match expr {
771        Expr::Column(column) => validate_column_table(column, table),
772        Expr::Value(_) => Ok(()),
773        Expr::Like { left, pattern } => {
774            validate_expr_table(Some(left), table)?;
775            validate_expr_table(Some(pattern), table)
776        }
777        Expr::Compare { left, right, .. }
778        | Expr::And { left, right }
779        | Expr::Or { left, right } => {
780            validate_expr_table(Some(left), table)?;
781            validate_expr_table(Some(right), table)
782        }
783        Expr::InQuery { left, query } => {
784            validate_expr_table(Some(left), table)?;
785            validate_subquery(query)
786        }
787        Expr::In { left, .. } => validate_expr_table(Some(left), table),
788        Expr::Not(expr) | Expr::IsNull(expr) | Expr::IsNotNull(expr) => {
789            validate_expr_table(Some(expr), table)
790        }
791    }
792}
793
794fn validate_column_table(column: &ColumnRef, table: &'static str) -> Result<(), QueryBuildError> {
795    if column.table == table {
796        Ok(())
797    } else {
798        Err(QueryBuildError::ForeignTableColumn {
799            column: column.name,
800            table: column.table,
801            expected_table: table,
802        })
803    }
804}
805
806fn validate_expr_tables(
807    expr: Option<&Expr>,
808    tables: &[&'static str],
809) -> Result<(), QueryBuildError> {
810    let Some(expr) = expr else {
811        return Ok(());
812    };
813    match expr {
814        Expr::Column(column) => {
815            if tables.contains(&column.table) {
816                Ok(())
817            } else {
818                Err(QueryBuildError::ForeignTableColumn {
819                    column: column.name,
820                    table: column.table,
821                    expected_table: tables[0],
822                })
823            }
824        }
825        Expr::Like { left, pattern } => {
826            validate_expr_tables(Some(left), tables)?;
827            validate_expr_tables(Some(pattern), tables)
828        }
829        Expr::Value(_) => Ok(()),
830        Expr::Compare { left, right, .. }
831        | Expr::And { left, right }
832        | Expr::Or { left, right } => {
833            validate_expr_tables(Some(left), tables)?;
834            validate_expr_tables(Some(right), tables)
835        }
836        Expr::InQuery { left, query } => {
837            validate_expr_tables(Some(left), tables)?;
838            validate_subquery(query)
839        }
840        Expr::In { left, .. } => validate_expr_tables(Some(left), tables),
841        Expr::Not(expr) | Expr::IsNull(expr) | Expr::IsNotNull(expr) => {
842            validate_expr_tables(Some(expr), tables)
843        }
844    }
845}
846
847fn validate_subquery(query: &SelectAst) -> Result<(), QueryBuildError> {
848    if query.columns.len() != 1 {
849        return Err(QueryBuildError::InvalidSchema(
850            "IN subquery must select one column".into(),
851        ));
852    }
853    let mut tables = vec![query.table.name];
854    for join in &query.joins {
855        tables.extend([join.table.name, join.alias]);
856    }
857    validate_expr_tables(Some(&Expr::Column(query.columns[0])), &tables)?;
858    QueryAst::Select(query.clone()).validate()
859}