quaint_forked/ast/select.rs
1use crate::ast::*;
2use std::borrow::Cow;
3
4/// A builder for a `SELECT` statement.
5#[derive(Debug, PartialEq, Clone, Default)]
6pub struct Select<'a> {
7 pub(crate) distinct: bool,
8 pub(crate) tables: Vec<Table<'a>>,
9 pub(crate) columns: Vec<Expression<'a>>,
10 pub(crate) conditions: Option<ConditionTree<'a>>,
11 pub(crate) ordering: Ordering<'a>,
12 pub(crate) grouping: Grouping<'a>,
13 pub(crate) having: Option<ConditionTree<'a>>,
14 pub(crate) limit: Option<Value<'a>>,
15 pub(crate) offset: Option<Value<'a>>,
16 pub(crate) joins: Vec<Join<'a>>,
17 pub(crate) ctes: Vec<CommonTableExpression<'a>>,
18 pub(crate) comment: Option<Cow<'a, str>>,
19}
20
21impl<'a> From<Select<'a>> for Expression<'a> {
22 fn from(sel: Select<'a>) -> Expression<'a> {
23 Expression {
24 kind: ExpressionKind::Selection(SelectQuery::Select(Box::new(sel))),
25 alias: None,
26 }
27 }
28}
29
30impl<'a> From<Select<'a>> for Query<'a> {
31 fn from(sel: Select<'a>) -> Query<'a> {
32 Query::Select(Box::new(sel))
33 }
34}
35
36impl<'a> Select<'a> {
37 /// Creates a new `SELECT` statement for the given table.
38 ///
39 /// ```rust
40 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
41 /// # fn main() -> Result<(), quaint::error::Error> {
42 /// let query = Select::from_table("users");
43 /// let (sql, _) = Sqlite::build(query)?;
44 ///
45 /// assert_eq!("SELECT `users`.* FROM `users`", sql);
46 /// # Ok(())
47 /// # }
48 /// ```
49 ///
50 /// The table can be in multiple parts, defining the database.
51 ///
52 /// ```rust
53 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
54 /// # fn main() -> Result<(), quaint::error::Error> {
55 /// let query = Select::from_table(("crm", "users"));
56 /// let (sql, _) = Sqlite::build(query)?;
57 ///
58 /// assert_eq!("SELECT `crm`.`users`.* FROM `crm`.`users`", sql);
59 /// # Ok(())
60 /// # }
61 /// ```
62 ///
63 /// Selecting from a nested `SELECT`.
64 ///
65 /// ```rust
66 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
67 /// # fn main() -> Result<(), quaint::error::Error> {
68 /// let select = Table::from(Select::default().value(1)).alias("num");
69 /// let query = Select::from_table(select.alias("num"));
70 /// let (sql, params) = Sqlite::build(query)?;
71 ///
72 /// assert_eq!("SELECT `num`.* FROM (SELECT ?) AS `num`", sql);
73 /// assert_eq!(vec![Value::from(1)], params);
74 /// # Ok(())
75 /// # }
76 /// ```
77 ///
78 /// Selecting from a set of values.
79 ///
80 /// ```rust
81 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
82 /// # use quaint::values;
83 /// # fn main() -> Result<(), quaint::error::Error> {
84 /// let expected_sql = "SELECT `vals`.* FROM (VALUES (?,?),(?,?)) AS `vals`";
85 /// let values = Table::from(values!((1, 2), (3, 4))).alias("vals");
86 /// let query = Select::from_table(values);
87 /// let (sql, params) = Sqlite::build(query)?;
88 ///
89 /// assert_eq!(expected_sql, sql);
90 /// assert_eq!(
91 /// vec![
92 /// Value::from(1),
93 /// Value::from(2),
94 /// Value::from(3),
95 /// Value::from(4),
96 /// ],
97 /// params
98 /// );
99 /// # Ok(())
100 /// # }
101 /// ```
102 pub fn from_table<T>(table: T) -> Self
103 where
104 T: Into<Table<'a>>,
105 {
106 Select {
107 tables: vec![table.into()],
108 ..Select::default()
109 }
110 }
111
112 /// Adds a table to be selected.
113 ///
114 /// ```rust
115 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
116 /// # fn main() -> Result<(), quaint::error::Error> {
117 /// let query = Select::from_table("users")
118 /// .and_from(Table::from(Select::default().value(1)).alias("num"))
119 /// .column(("users", "name"))
120 /// .value(Table::from("num").asterisk());
121 ///
122 /// let (sql, _) = Sqlite::build(query)?;
123 ///
124 /// assert_eq!("SELECT `users`.`name`, `num`.* FROM `users`, (SELECT ?) AS `num`", sql);
125 /// # Ok(())
126 /// # }
127 /// ```
128 pub fn and_from<T>(mut self, table: T) -> Self
129 where
130 T: Into<Table<'a>>,
131 {
132 self.tables.push(table.into());
133 self
134 }
135
136 /// Selects a static value as the column.
137 ///
138 /// ```rust
139 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
140 /// # fn main() -> Result<(), quaint::error::Error> {
141 /// let query = Select::default().value(1);
142 /// let (sql, params) = Sqlite::build(query)?;
143 ///
144 /// assert_eq!("SELECT ?", sql);
145 /// assert_eq!(vec![Value::from(1)], params);
146 /// # Ok(())
147 /// # }
148 /// ```
149 ///
150 /// Creating a qualified asterisk to a joined table:
151 ///
152 /// ```rust
153 /// # use quaint::{col, val, ast::*, visitor::{Visitor, Sqlite}};
154 /// # fn main() -> Result<(), quaint::error::Error> {
155 /// let join = "dogs".on(("dogs", "slave_id").equals(Column::from(("cats", "master_id"))));
156 ///
157 /// let query = Select::from_table("cats")
158 /// .value(Table::from("cats").asterisk())
159 /// .value(col!("dogs", "age") - val!(4))
160 /// .inner_join(join);
161 ///
162 /// let (sql, params) = Sqlite::build(query)?;
163 ///
164 /// assert_eq!(
165 /// "SELECT `cats`.*, (`dogs`.`age` - ?) FROM `cats` INNER JOIN `dogs` ON `dogs`.`slave_id` = `cats`.`master_id`",
166 /// sql
167 /// );
168 ///
169 /// assert_eq!(vec![Value::from(4)], params);
170 /// # Ok(())
171 /// # }
172 /// ```
173 pub fn value<T>(mut self, value: T) -> Self
174 where
175 T: Into<Expression<'a>>,
176 {
177 self.columns.push(value.into());
178 self
179 }
180
181 /// Adds a column to be selected.
182 ///
183 /// ```rust
184 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
185 /// # fn main() -> Result<(), quaint::error::Error> {
186 /// let query = Select::from_table("users")
187 /// .column("name")
188 /// .column(("users", "id"))
189 /// .column((("crm", "users"), "foo"));
190 ///
191 /// let (sql, _) = Sqlite::build(query)?;
192 ///
193 /// assert_eq!("SELECT `name`, `users`.`id`, `crm`.`users`.`foo` FROM `users`", sql);
194 /// # Ok(())
195 /// # }
196 /// ```
197 pub fn column<T>(mut self, column: T) -> Self
198 where
199 T: Into<Column<'a>>,
200 {
201 self.columns.push(column.into().into());
202 self
203 }
204
205 /// A bulk method to select multiple values.
206 ///
207 /// ```rust
208 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
209 /// # fn main() -> Result<(), quaint::error::Error> {
210 /// let query = Select::from_table("users").columns(vec!["foo", "bar"]);
211 /// let (sql, _) = Sqlite::build(query)?;
212 ///
213 /// assert_eq!("SELECT `foo`, `bar` FROM `users`", sql);
214 /// # Ok(())
215 /// # }
216 /// ```
217 pub fn columns<T, C>(mut self, columns: T) -> Self
218 where
219 T: IntoIterator<Item = C>,
220 C: Into<Column<'a>>,
221 {
222 self.columns = columns.into_iter().map(|c| c.into().into()).collect();
223 self
224 }
225
226 /// Adds `DISTINCT` to the select query.
227 ///
228 /// ```rust
229 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
230 /// # fn main() -> Result<(), quaint::error::Error> {
231 /// let query = Select::from_table("users").column("foo").column("bar").distinct();
232 /// let (sql, _) = Sqlite::build(query)?;
233 ///
234 /// assert_eq!("SELECT DISTINCT `foo`, `bar` FROM `users`", sql);
235 /// # Ok(())
236 /// # }
237 /// ```
238 pub fn distinct(mut self) -> Self {
239 self.distinct = true;
240 self
241 }
242
243 /// Adds `WHERE` conditions to the query, replacing the previous conditions.
244 /// See [Comparable](trait.Comparable.html#required-methods) for more
245 /// examples.
246 ///
247 /// ```rust
248 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
249 /// # fn main() -> Result<(), quaint::error::Error> {
250 /// let query = Select::from_table("users").so_that("foo".equals("bar"));
251 /// let (sql, params) = Sqlite::build(query)?;
252 ///
253 /// assert_eq!("SELECT `users`.* FROM `users` WHERE `foo` = ?", sql);
254 ///
255 /// assert_eq!(vec![
256 /// Value::from("bar"),
257 /// ], params);
258 /// # Ok(())
259 /// # }
260 /// ```
261 pub fn so_that<T>(mut self, conditions: T) -> Self
262 where
263 T: Into<ConditionTree<'a>>,
264 {
265 self.conditions = Some(conditions.into());
266 self
267 }
268
269 /// Adds an additional `WHERE` condition to the query combining the possible
270 /// previous condition with `AND`. See
271 /// [Comparable](trait.Comparable.html#required-methods) for more examples.
272 ///
273 /// ```rust
274 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
275 /// # fn main() -> Result<(), quaint::error::Error> {
276 /// let query = Select::from_table("users")
277 /// .so_that("foo".equals("bar"))
278 /// .and_where("lol".equals("wtf"));
279 ///
280 /// let (sql, params) = Sqlite::build(query)?;
281 ///
282 /// assert_eq!("SELECT `users`.* FROM `users` WHERE (`foo` = ? AND `lol` = ?)", sql);
283 ///
284 /// assert_eq!(vec![
285 /// Value::from("bar"),
286 /// Value::from("wtf"),
287 /// ], params);
288 /// # Ok(())
289 /// # }
290 /// ```
291 pub fn and_where<T>(mut self, conditions: T) -> Self
292 where
293 T: Into<ConditionTree<'a>>,
294 {
295 match self.conditions {
296 Some(previous) => {
297 self.conditions = Some(previous.and(conditions.into()));
298 self
299 }
300 None => self.so_that(conditions),
301 }
302 }
303
304 /// Adds an additional `WHERE` condition to the query combining the possible
305 /// previous condition with `OR`. See
306 /// [Comparable](trait.Comparable.html#required-methods) for more examples.
307 ///
308 /// ```rust
309 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
310 /// # fn main() -> Result<(), quaint::error::Error> {
311 /// let query = Select::from_table("users")
312 /// .so_that("foo".equals("bar"))
313 /// .or_where("lol".equals("wtf"));
314 ///
315 /// let (sql, params) = Sqlite::build(query)?;
316 ///
317 /// assert_eq!("SELECT `users`.* FROM `users` WHERE (`foo` = ? OR `lol` = ?)", sql);
318 ///
319 /// assert_eq!(vec![
320 /// Value::from("bar"),
321 /// Value::from("wtf"),
322 /// ], params);
323 /// # Ok(())
324 /// # }
325 /// ```
326 pub fn or_where<T>(mut self, conditions: T) -> Self
327 where
328 T: Into<ConditionTree<'a>>,
329 {
330 match self.conditions {
331 Some(previous) => {
332 self.conditions = Some(previous.or(conditions.into()));
333 self
334 }
335 None => self.so_that(conditions),
336 }
337 }
338
339 /// Adds `INNER JOIN` clause to the query.
340 ///
341 /// ```rust
342 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
343 /// # fn main() -> Result<(), quaint::error::Error> {
344 /// let join = "posts".alias("p").on(("p", "user_id").equals(Column::from(("users", "id"))));
345 /// let query = Select::from_table("users").inner_join(join);
346 /// let (sql, _) = Sqlite::build(query)?;
347 ///
348 /// assert_eq!(
349 /// "SELECT `users`.* FROM `users` INNER JOIN `posts` AS `p` ON `p`.`user_id` = `users`.`id`",
350 /// sql
351 /// );
352 /// # Ok(())
353 /// # }
354 /// ```
355 pub fn inner_join<J>(mut self, join: J) -> Self
356 where
357 J: Into<JoinData<'a>>,
358 {
359 self.joins.push(Join::Inner(join.into()));
360 self
361 }
362
363 /// Adds `LEFT JOIN` clause to the query.
364 ///
365 /// ```rust
366 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
367 /// # fn main() -> Result<(), quaint::error::Error> {
368 /// let join = "posts".alias("p").on(("p", "visible").equals(true));
369 /// let query = Select::from_table("users").left_join(join);
370 /// let (sql, params) = Sqlite::build(query)?;
371 ///
372 /// assert_eq!(
373 /// "SELECT `users`.* FROM `users` LEFT JOIN `posts` AS `p` ON `p`.`visible` = ?",
374 /// sql
375 /// );
376 ///
377 /// assert_eq!(
378 /// vec![
379 /// Value::from(true),
380 /// ],
381 /// params
382 /// );
383 /// # Ok(())
384 /// # }
385 /// ```
386 pub fn left_join<J>(mut self, join: J) -> Self
387 where
388 J: Into<JoinData<'a>>,
389 {
390 self.joins.push(Join::Left(join.into()));
391 self
392 }
393
394 /// Adds `RIGHT JOIN` clause to the query.
395 ///
396 /// ```rust
397 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
398 /// # fn main() -> Result<(), quaint::error::Error> {
399 /// let join = "posts".alias("p").on(("p", "visible").equals(true));
400 /// let query = Select::from_table("users").right_join(join);
401 /// let (sql, params) = Sqlite::build(query)?;
402 ///
403 /// assert_eq!(
404 /// "SELECT `users`.* FROM `users` RIGHT JOIN `posts` AS `p` ON `p`.`visible` = ?",
405 /// sql
406 /// );
407 ///
408 /// assert_eq!(
409 /// vec![
410 /// Value::from(true),
411 /// ],
412 /// params
413 /// );
414 /// # Ok(())
415 /// # }
416 /// ```
417 pub fn right_join<J>(mut self, join: J) -> Self
418 where
419 J: Into<JoinData<'a>>,
420 {
421 self.joins.push(Join::Right(join.into()));
422 self
423 }
424
425 /// Adds `FULL JOIN` clause to the query.
426 ///
427 /// ```rust
428 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
429 /// # fn main() -> Result<(), quaint::error::Error> {
430 /// let join = "posts".alias("p").on(("p", "visible").equals(true));
431 /// let query = Select::from_table("users").full_join(join);
432 /// let (sql, params) = Sqlite::build(query)?;
433 ///
434 /// assert_eq!(
435 /// "SELECT `users`.* FROM `users` FULL JOIN `posts` AS `p` ON `p`.`visible` = ?",
436 /// sql
437 /// );
438 ///
439 /// assert_eq!(
440 /// vec![
441 /// Value::from(true),
442 /// ],
443 /// params
444 /// );
445 /// # Ok(())
446 /// # }
447 /// ```
448 pub fn full_join<J>(mut self, join: J) -> Self
449 where
450 J: Into<JoinData<'a>>,
451 {
452 self.joins.push(Join::Full(join.into()));
453 self
454 }
455
456 /// Adds an ordering to the `ORDER BY` section.
457 ///
458 /// ```rust
459 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
460 /// # fn main() -> Result<(), quaint::error::Error> {
461 /// let query = Select::from_table("users")
462 /// .order_by("foo")
463 /// .order_by("baz".ascend())
464 /// .order_by("bar".descend());
465 ///
466 /// let (sql, _) = Sqlite::build(query)?;
467 ///
468 /// assert_eq!("SELECT `users`.* FROM `users` ORDER BY `foo`, `baz` ASC, `bar` DESC", sql);
469 /// # Ok(())
470 /// # }
471 pub fn order_by<T>(mut self, value: T) -> Self
472 where
473 T: IntoOrderDefinition<'a>,
474 {
475 self.ordering = self.ordering.append(value.into_order_definition());
476 self
477 }
478
479 /// Adds a grouping to the `GROUP BY` section.
480 ///
481 /// This does not check if the grouping is actually valid in respect to aggregated columns.
482 ///
483 /// ```rust
484 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
485 /// # fn main() -> Result<(), quaint::error::Error> {
486 /// let query = Select::from_table("users").column("foo").column("bar")
487 /// .group_by("foo")
488 /// .group_by("bar");
489 ///
490 /// let (sql, _) = Sqlite::build(query)?;
491 ///
492 /// assert_eq!("SELECT `foo`, `bar` FROM `users` GROUP BY `foo`, `bar`", sql);
493 /// # Ok(())
494 /// # }
495 pub fn group_by<T>(mut self, value: T) -> Self
496 where
497 T: IntoGroupByDefinition<'a>,
498 {
499 self.grouping = self.grouping.append(value.into_group_by_definition());
500 self
501 }
502
503 /// Adds group conditions to a query. Should be combined together with a
504 /// [group_by](struct.Select.html#method.group_by) statement.
505 ///
506 /// ```rust
507 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
508 /// # fn main() -> Result<(), quaint::error::Error> {
509 /// let query = Select::from_table("users").column("foo").column("bar")
510 /// .group_by("foo")
511 /// .having("foo".greater_than(100));
512 ///
513 /// let (sql, params) = Sqlite::build(query)?;
514 ///
515 /// assert_eq!("SELECT `foo`, `bar` FROM `users` GROUP BY `foo` HAVING `foo` > ?", sql);
516 /// assert_eq!(vec![Value::from(100)], params);
517 /// # Ok(())
518 /// # }
519 pub fn having<T>(mut self, conditions: T) -> Self
520 where
521 T: Into<ConditionTree<'a>>,
522 {
523 self.having = Some(conditions.into());
524 self
525 }
526
527 /// Sets the `LIMIT` value.
528 ///
529 /// ```rust
530 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
531 /// # fn main() -> Result<(), quaint::error::Error> {
532 /// let query = Select::from_table("users").limit(10);
533 /// let (sql, params) = Sqlite::build(query)?;
534 ///
535 /// assert_eq!("SELECT `users`.* FROM `users` LIMIT ?", sql);
536 /// assert_eq!(vec![Value::from(10_i64)], params);
537 /// # Ok(())
538 /// # }
539 pub fn limit(mut self, limit: usize) -> Self {
540 self.limit = Some(Value::from(limit));
541 self
542 }
543
544 /// Sets the `OFFSET` value.
545 ///
546 /// ```rust
547 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
548 /// # fn main() -> Result<(), quaint::error::Error> {
549 /// let query = Select::from_table("users").offset(10);
550 /// let (sql, params) = Sqlite::build(query)?;
551 ///
552 /// assert_eq!("SELECT `users`.* FROM `users` LIMIT ? OFFSET ?", sql);
553 /// assert_eq!(vec![Value::from(-1), Value::from(10_i64)], params);
554 /// # Ok(())
555 /// # }
556 pub fn offset(mut self, offset: usize) -> Self {
557 self.offset = Some(Value::from(offset));
558 self
559 }
560
561 /// Adds a comment to the select.
562 ///
563 /// ```rust
564 /// # use quaint::{ast::*, visitor::{Visitor, Sqlite}};
565 /// # fn main() -> Result<(), quaint::error::Error> {
566 /// let query = Select::from_table("users").comment("trace_id='5bd66ef5095369c7b0d1f8f4bd33716a', parent_id='c532cb4098ac3dd2'");
567 /// let (sql, _) = Sqlite::build(query)?;
568 ///
569 /// assert_eq!("SELECT `users`.* FROM `users` /* trace_id='5bd66ef5095369c7b0d1f8f4bd33716a', parent_id='c532cb4098ac3dd2' */", sql);
570 /// # Ok(())
571 /// # }
572 /// ```
573 pub fn comment<C: Into<Cow<'a, str>>>(mut self, comment: C) -> Self {
574 self.comment = Some(comment.into());
575 self
576 }
577
578 /// Adds a common table expression to the select.
579 ///
580 /// ```rust
581 /// # use quaint::{val, ast::*, visitor::{Visitor, Sqlite}};
582 /// # fn main() -> Result<(), quaint::error::Error> {
583 /// let cte = Select::default()
584 /// .value(val!(1).alias("val"))
585 /// .into_cte("one")
586 /// .column("val");
587 ///
588 /// let query = Select::from_table("one")
589 /// .column("val")
590 /// .with(cte);
591 ///
592 /// let (sql, params) = Sqlite::build(query)?;
593 ///
594 /// assert_eq!("WITH `one` (`val`) AS (SELECT ? AS `val`) SELECT `val` FROM `one`", sql);
595 /// assert_eq!(vec![Value::from(1)], params);
596 /// # Ok(())
597 /// # }
598 /// ```
599 ///
600 /// # Panics
601 ///
602 /// Please note that for some databases, a tuple conversion can inject
603 /// expressions. These will be named in the form of `cte_n`, where `n`
604 /// represents a number from `0` to up. Using these names might cause
605 /// a panic.
606 pub fn with(mut self, cte: CommonTableExpression<'a>) -> Self {
607 self.ctes.push(cte);
608 self
609 }
610
611 /// Traverse the condition tree, looking for a comparison where the left
612 /// side is a tuple and the right side a nested `SELECT` in an `IN` or `NOT
613 /// IN` operation; converting it to a common table expression.
614 ///
615 /// So the following query:
616 ///
617 /// ```sql
618 /// SELECT * FROM A WHERE (x, y) IN (SELECT a, b FROM B)
619 /// ```
620 ///
621 /// turns into:
622 ///
623 /// ```sql
624 /// WITH cte_0 AS (SELECT a, b FROM B)
625 /// SELECT * FROM A
626 /// WHERE x IN (SELECT a FROM cte_0 WHERE b = y)
627 /// ```
628 ///
629 /// This makes possible certain tuple comparisons in databases which do not
630 /// support them, allowing the same query AST to be used throughout
631 /// different systems.
632 ///
633 /// The function traverses the whole tree, converting all matching cases.
634 /// Does nothing if any of the following rules fail:
635 ///
636 /// - Not comparing a tuple (e.g. `x IN (SELECT ...)`)
637 /// - Not using a `IN` or `NOT IN` operation
638 /// - Imbalanced number of variables (e.g. `(x, y, z) IN (SELECT a, b ...)`)
639 #[cfg(feature = "mssql")]
640 pub(crate) fn convert_tuple_selects_to_ctes(
641 mut self,
642 top_level: bool,
643 level: &mut usize,
644 ) -> either::Either<Self, (Self, Vec<CommonTableExpression<'a>>)> {
645 let ctes: Vec<CommonTableExpression<'_>> = self
646 .conditions
647 .take()
648 .map(|tree| {
649 let (tree, ctes) = tree.convert_tuple_selects_to_ctes(level);
650 self.conditions = Some(tree);
651
652 ctes.into_iter().collect()
653 })
654 .unwrap_or_else(Vec::new);
655
656 if top_level {
657 let clashing_names = self
658 .ctes
659 .iter()
660 .any(|c| ctes.iter().any(|c2| c.identifier == c2.identifier));
661
662 assert!(!clashing_names);
663 self.ctes.extend(ctes);
664
665 either::Either::Left(self)
666 } else {
667 either::Either::Right((self, ctes))
668 }
669 }
670
671 /// A list of item names in the query, skipping the anonymous values or
672 /// columns.
673 pub(crate) fn named_selection(&self) -> Vec<String> {
674 // Empty vector marks selection of everything.
675 if self.columns.len() == 1 && self.columns.first().map(|c| c.is_asterisk()).unwrap_or(false) {
676 return Vec::new();
677 }
678
679 self.columns
680 .iter()
681 .filter_map(|expr| match &expr.kind {
682 ExpressionKind::Column(c) => c
683 .alias
684 .as_ref()
685 .map(|a| a.to_string())
686 .or_else(|| expr.alias.as_ref().map(|a| a.to_string()))
687 .or_else(|| Some(c.name.to_string())),
688 ExpressionKind::Parameterized(_) => expr.alias.as_ref().map(|a| a.to_string()),
689 _ => None,
690 })
691 .collect()
692 }
693}
694
695impl<'a> IntoCommonTableExpression<'a> for Select<'a> {}