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)]
181pub 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 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
256pub trait Model: Sized {
258 type PrimaryKey: crate::PrimaryKey;
259 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 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 #[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 fn write_protected_columns() -> &'static [&'static str] {
298 &[]
299 }
300 fn json_columns() -> &'static [&'static str] {
302 &[]
303 }
304 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
339pub 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
355pub 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#[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#[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}