risingwave_sqlparser/ast/
query.rs

1// Licensed under the Apache License, Version 2.0 (the "License");
2// you may not use this file except in compliance with the License.
3// You may obtain a copy of the License at
4//
5//     http://www.apache.org/licenses/LICENSE-2.0
6//
7// Unless required by applicable law or agreed to in writing, software
8// distributed under the License is distributed on an "AS IS" BASIS,
9// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
10// See the License for the specific language governing permissions and
11// limitations under the License.
12
13#[cfg(not(feature = "std"))]
14use alloc::{boxed::Box, vec::Vec};
15
16#[cfg(feature = "serde")]
17use serde::{Deserialize, Serialize};
18
19use crate::ast::*;
20
21/// The most complete variant of a `SELECT` query expression, optionally
22/// including `WITH`, `UNION` / other set operations, and `ORDER BY`.
23#[derive(Debug, Clone, PartialEq, Eq, Hash)]
24#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
25pub struct Query {
26    /// WITH (common table expressions, or CTEs)
27    pub with: Option<With>,
28    /// SELECT or UNION / EXCEPT / INTERSECT
29    pub body: SetExpr,
30    /// ORDER BY
31    pub order_by: Vec<OrderByExpr>,
32    /// `LIMIT { <N> | ALL }`
33    pub limit: Option<Expr>,
34    /// `OFFSET <N> [ { ROW | ROWS } ]`
35    ///
36    /// `ROW` and `ROWS` are noise words that don't influence the effect of the clause.
37    /// They are provided for ANSI compatibility.
38    pub offset: Option<String>,
39    /// `FETCH { FIRST | NEXT } <N> [ PERCENT ] { ROW | ROWS } | { ONLY | WITH TIES }`
40    ///
41    /// `ROW` and `ROWS` as well as `FIRST` and `NEXT` are noise words that don't influence the
42    /// effect of the clause. They are provided for ANSI compatibility.
43    pub fetch: Option<Fetch>,
44}
45
46impl Query {
47    /// Simple `VALUES` without other clauses.
48    pub fn as_simple_values(&self) -> Option<&Values> {
49        match &self {
50            Query {
51                with: None,
52                body: SetExpr::Values(values),
53                order_by,
54                limit: None,
55                offset: None,
56                fetch: None,
57            } if order_by.is_empty() => Some(values),
58            _ => None,
59        }
60    }
61}
62
63impl fmt::Display for Query {
64    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
65        if let Some(ref with) = self.with {
66            write!(f, "{} ", with)?;
67        }
68        write!(f, "{}", self.body)?;
69        if !self.order_by.is_empty() {
70            write!(f, " ORDER BY {}", display_comma_separated(&self.order_by))?;
71        }
72        if let Some(ref limit) = self.limit {
73            write!(f, " LIMIT {}", limit)?;
74        }
75        if let Some(ref offset) = self.offset {
76            write!(f, " OFFSET {}", offset)?;
77        }
78        if let Some(ref fetch) = self.fetch {
79            write!(f, " {}", fetch)?;
80        }
81        Ok(())
82    }
83}
84
85/// A node in a tree, representing a "query body" expression, roughly:
86/// `SELECT ... [ {UNION|EXCEPT|INTERSECT} SELECT ...]`
87#[allow(clippy::large_enum_variant)]
88#[derive(Debug, Clone, PartialEq, Eq, Hash)]
89#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
90pub enum SetExpr {
91    /// Restricted SELECT .. FROM .. HAVING (no ORDER BY or set operations)
92    Select(Box<Select>),
93    /// Parenthesized SELECT subquery, which may include more set operations
94    /// in its body and an optional ORDER BY / LIMIT.
95    Query(Box<Query>),
96    /// UNION/EXCEPT/INTERSECT of two queries
97    SetOperation {
98        op: SetOperator,
99        all: bool,
100        corresponding: Corresponding,
101        left: Box<SetExpr>,
102        right: Box<SetExpr>,
103    },
104    Values(Values),
105}
106
107impl fmt::Display for SetExpr {
108    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
109        match self {
110            SetExpr::Select(s) => write!(f, "{}", s),
111            SetExpr::Query(q) => write!(f, "({})", q),
112            SetExpr::Values(v) => write!(f, "{}", v),
113            SetExpr::SetOperation {
114                left,
115                right,
116                op,
117                all,
118                corresponding,
119            } => {
120                let all_str = if *all { " ALL" } else { "" };
121                write!(f, "{} {}{}{} {}", left, op, all_str, corresponding, right)
122            }
123        }
124    }
125}
126
127#[derive(Debug, Clone, PartialEq, Eq, Hash)]
128#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
129pub enum SetOperator {
130    Union,
131    Except,
132    Intersect,
133}
134
135impl fmt::Display for SetOperator {
136    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
137        f.write_str(match self {
138            SetOperator::Union => "UNION",
139            SetOperator::Except => "EXCEPT",
140            SetOperator::Intersect => "INTERSECT",
141        })
142    }
143}
144
145#[derive(Debug, Clone, PartialEq, Eq, Hash)]
146#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
147/// `CORRESPONDING [ BY <left paren> <corresponding column list> <right paren> ]`
148pub struct Corresponding {
149    pub corresponding: bool,
150    pub column_list: Option<Vec<Ident>>,
151}
152
153impl Corresponding {
154    pub fn with_column_list(column_list: Option<Vec<Ident>>) -> Self {
155        Self {
156            corresponding: true,
157            column_list,
158        }
159    }
160
161    pub fn none() -> Self {
162        Self {
163            corresponding: false,
164            column_list: None,
165        }
166    }
167
168    pub fn is_corresponding(&self) -> bool {
169        self.corresponding
170    }
171
172    pub fn column_list(&self) -> Option<&[Ident]> {
173        self.column_list.as_deref()
174    }
175}
176
177impl fmt::Display for Corresponding {
178    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
179        if self.corresponding {
180            write!(f, " CORRESPONDING")?;
181            if let Some(column_list) = &self.column_list {
182                write!(f, " BY ({})", display_comma_separated(column_list))?;
183            }
184        }
185        Ok(())
186    }
187}
188
189/// A restricted variant of `SELECT` (without CTEs/`ORDER BY`), which may
190/// appear either as the only body item of an `SQLQuery`, or as an operand
191/// to a set operation like `UNION`.
192#[derive(Default, Debug, Clone, PartialEq, Eq, Hash)]
193#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
194pub struct Select {
195    pub distinct: Distinct,
196    /// projection expressions
197    pub projection: Vec<SelectItem>,
198    /// FROM
199    pub from: Vec<TableWithJoins>,
200    /// LATERAL VIEWs
201    pub lateral_views: Vec<LateralView>,
202    /// WHERE
203    pub selection: Option<Expr>,
204    /// GROUP BY
205    pub group_by: Vec<Expr>,
206    /// HAVING
207    pub having: Option<Expr>,
208}
209
210impl fmt::Display for Select {
211    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
212        write!(f, "SELECT{}", &self.distinct)?;
213        write!(f, " {}", display_comma_separated(&self.projection))?;
214        if !self.from.is_empty() {
215            write!(f, " FROM {}", display_comma_separated(&self.from))?;
216        }
217        if !self.lateral_views.is_empty() {
218            for lv in &self.lateral_views {
219                write!(f, "{}", lv)?;
220            }
221        }
222        if let Some(ref selection) = self.selection {
223            write!(f, " WHERE {}", selection)?;
224        }
225        if !self.group_by.is_empty() {
226            write!(f, " GROUP BY {}", display_comma_separated(&self.group_by))?;
227        }
228        if let Some(ref having) = self.having {
229            write!(f, " HAVING {}", having)?;
230        }
231        Ok(())
232    }
233}
234
235/// An `ALL`, `DISTINCT` or `DISTINCT ON (expr, ...)` after `SELECT`.
236#[derive(Debug, Clone, PartialEq, Eq, Hash, Default)]
237#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
238#[expect(clippy::enum_variant_names)]
239pub enum Distinct {
240    /// An optional parameter that returns all matching rows.
241    #[default]
242    All,
243    /// A parameter that removes duplicates from the result-set.
244    Distinct,
245    /// An optional parameter that eliminates duplicate data based on the expressions.
246    DistinctOn(Vec<Expr>),
247}
248
249impl Distinct {
250    pub const fn is_all(&self) -> bool {
251        matches!(self, Distinct::All)
252    }
253
254    pub const fn is_distinct(&self) -> bool {
255        matches!(self, Distinct::Distinct)
256    }
257}
258
259impl fmt::Display for Distinct {
260    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
261        match self {
262            Distinct::All => write!(f, ""),
263            Distinct::Distinct => write!(f, " DISTINCT"),
264            Distinct::DistinctOn(exprs) => {
265                write!(f, " DISTINCT ON ({})", display_comma_separated(exprs))
266            }
267        }
268    }
269}
270
271/// A hive LATERAL VIEW with potential column aliases
272#[derive(Debug, Clone, PartialEq, Eq, Hash)]
273#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
274pub struct LateralView {
275    /// LATERAL VIEW
276    pub lateral_view: Expr,
277    /// LATERAL VIEW table name
278    pub lateral_view_name: ObjectName,
279    /// LATERAL VIEW optional column aliases
280    pub lateral_col_alias: Vec<Ident>,
281    /// LATERAL VIEW OUTER
282    pub outer: bool,
283}
284
285impl fmt::Display for LateralView {
286    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
287        write!(
288            f,
289            " LATERAL VIEW{outer} {} {}",
290            self.lateral_view,
291            self.lateral_view_name,
292            outer = if self.outer { " OUTER" } else { "" }
293        )?;
294        if !self.lateral_col_alias.is_empty() {
295            write!(
296                f,
297                " AS {}",
298                display_comma_separated(&self.lateral_col_alias)
299            )?;
300        }
301        Ok(())
302    }
303}
304
305#[derive(Debug, Clone, PartialEq, Eq, Hash)]
306#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
307pub struct With {
308    pub recursive: bool,
309    pub cte_tables: Vec<Cte>,
310}
311
312impl fmt::Display for With {
313    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
314        write!(
315            f,
316            "WITH {}{}",
317            if self.recursive { "RECURSIVE " } else { "" },
318            display_comma_separated(&self.cte_tables)
319        )
320    }
321}
322
323/// A single CTE (used after `WITH`): `alias [(col1, col2, ...)] AS ( query )`
324///
325/// The names in the column list before `AS`, when specified, replace the names
326/// of the columns returned by the query. The parser does not validate that the
327/// number of columns in the query matches the number of columns in the query.
328#[derive(Debug, Clone, PartialEq, Eq, Hash)]
329#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
330pub struct Cte {
331    pub alias: TableAlias,
332    pub cte_inner: CteInner,
333}
334
335impl fmt::Display for Cte {
336    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
337        match &self.cte_inner {
338            CteInner::Query(query) => write!(f, "{} AS ({})", self.alias, query)?,
339            CteInner::ChangeLog(obj_name) => {
340                write!(f, "{} AS changelog from {}", self.alias, obj_name)?
341            }
342        }
343        Ok(())
344    }
345}
346
347#[derive(Debug, Clone, PartialEq, Eq, Hash)]
348#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
349pub enum CteInner {
350    Query(Box<Query>),
351    ChangeLog(ObjectName),
352}
353
354/// One item of the comma-separated list following `SELECT`
355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
356#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
357pub enum SelectItem {
358    /// Any expression, not followed by `[ AS ] alias`
359    UnnamedExpr(Expr),
360    /// Expr is an arbitrary expression, returning either a table or a column.
361    /// Idents are the prefix of `*`, which are consecutive field accesses.
362    /// e.g. `(table.v1).*` or `(table).v1.*`
363    ExprQualifiedWildcard(Expr, Vec<Ident>),
364    /// An expression, followed by `[ AS ] alias`
365    ExprWithAlias { expr: Expr, alias: Ident },
366    /// `alias.*` or even `schema.table.*` followed by optional except
367    QualifiedWildcard(ObjectName, Option<Vec<Expr>>),
368    /// An unqualified `*`, or `* except (exprs)`
369    Wildcard(Option<Vec<Expr>>),
370}
371
372impl fmt::Display for SelectItem {
373    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
374        match &self {
375            SelectItem::UnnamedExpr(expr) => write!(f, "{}", expr),
376            SelectItem::ExprWithAlias { expr, alias } => write!(f, "{} AS {}", expr, alias),
377            SelectItem::ExprQualifiedWildcard(expr, prefix) => write!(
378                f,
379                "({}){}.*",
380                expr,
381                prefix
382                    .iter()
383                    .format_with("", |i, f| f(&format_args!(".{i}")))
384            ),
385            SelectItem::QualifiedWildcard(prefix, except) => match except {
386                Some(cols) => write!(
387                    f,
388                    "{}.* EXCEPT ({})",
389                    prefix,
390                    cols.iter()
391                        .map(|v| v.to_string())
392                        .collect::<Vec<String>>()
393                        .as_slice()
394                        .join(", ")
395                ),
396                None => write!(f, "{}.*", prefix),
397            },
398            SelectItem::Wildcard(except) => match except {
399                Some(cols) => write!(
400                    f,
401                    "* EXCEPT ({})",
402                    cols.iter()
403                        .map(|v| v.to_string())
404                        .collect::<Vec<String>>()
405                        .as_slice()
406                        .join(", ")
407                ),
408                None => write!(f, "*"),
409            },
410        }
411    }
412}
413
414#[derive(Debug, Clone, PartialEq, Eq, Hash)]
415#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
416pub struct TableWithJoins {
417    pub relation: TableFactor,
418    pub joins: Vec<Join>,
419}
420
421impl fmt::Display for TableWithJoins {
422    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
423        write!(f, "{}", self.relation)?;
424        for join in &self.joins {
425            write!(f, "{}", join)?;
426        }
427        Ok(())
428    }
429}
430
431/// A table name or a parenthesized subquery with an optional alias
432#[derive(Debug, Clone, PartialEq, Eq, Hash)]
433#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
434pub enum TableFactor {
435    Table {
436        name: ObjectName,
437        alias: Option<TableAlias>,
438        as_of: Option<AsOf>,
439    },
440    Derived {
441        lateral: bool,
442        subquery: Box<Query>,
443        alias: Option<TableAlias>,
444    },
445    /// `<expr>(args)[ AS <alias> ]`
446    ///
447    /// Note that scalar functions can also be used in this way.
448    TableFunction {
449        name: ObjectName,
450        alias: Option<TableAlias>,
451        args: Vec<FunctionArg>,
452        with_ordinality: bool,
453    },
454    /// Represents a parenthesized table factor. The SQL spec only allows a
455    /// join expression (`(foo <JOIN> bar [ <JOIN> baz ... ])`) to be nested,
456    /// possibly several times.
457    ///
458    /// The parser may also accept non-standard nesting of bare tables for some
459    /// dialects, but the information about such nesting is stripped from AST.
460    NestedJoin(Box<TableWithJoins>),
461}
462
463impl fmt::Display for TableFactor {
464    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
465        match self {
466            TableFactor::Table { name, alias, as_of } => {
467                write!(f, "{}", name)?;
468                if let Some(as_of) = as_of {
469                    write!(f, "{}", as_of)?
470                }
471                if let Some(alias) = alias {
472                    write!(f, " AS {}", alias)?;
473                }
474                Ok(())
475            }
476            TableFactor::Derived {
477                lateral,
478                subquery,
479                alias,
480            } => {
481                if *lateral {
482                    write!(f, "LATERAL ")?;
483                }
484                write!(f, "({})", subquery)?;
485                if let Some(alias) = alias {
486                    write!(f, " AS {}", alias)?;
487                }
488                Ok(())
489            }
490            TableFactor::TableFunction {
491                name,
492                alias,
493                args,
494                with_ordinality,
495            } => {
496                write!(f, "{}({})", name, display_comma_separated(args))?;
497                if *with_ordinality {
498                    write!(f, " WITH ORDINALITY")?;
499                }
500                if let Some(alias) = alias {
501                    write!(f, " AS {}", alias)?;
502                }
503                Ok(())
504            }
505            TableFactor::NestedJoin(table_reference) => write!(f, "({})", table_reference),
506        }
507    }
508}
509
510#[derive(Debug, Clone, PartialEq, Eq, Hash)]
511#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
512pub struct TableAlias {
513    pub name: Ident,
514    pub columns: Vec<Ident>,
515}
516
517impl fmt::Display for TableAlias {
518    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
519        write!(f, "{}", self.name)?;
520        if !self.columns.is_empty() {
521            write!(f, " ({})", display_comma_separated(&self.columns))?;
522        }
523        Ok(())
524    }
525}
526
527#[derive(Debug, Clone, PartialEq, Eq, Hash)]
528#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
529pub struct Join {
530    pub relation: TableFactor,
531    pub join_operator: JoinOperator,
532}
533
534impl fmt::Display for Join {
535    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
536        fn prefix(constraint: &JoinConstraint) -> &'static str {
537            match constraint {
538                JoinConstraint::Natural => "NATURAL ",
539                _ => "",
540            }
541        }
542        fn suffix(constraint: &'_ JoinConstraint) -> impl fmt::Display + '_ {
543            struct Suffix<'a>(&'a JoinConstraint);
544            impl fmt::Display for Suffix<'_> {
545                fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
546                    match self.0 {
547                        JoinConstraint::On(expr) => write!(f, " ON {}", expr),
548                        JoinConstraint::Using(attrs) => {
549                            write!(f, " USING({})", display_comma_separated(attrs))
550                        }
551                        _ => Ok(()),
552                    }
553                }
554            }
555            Suffix(constraint)
556        }
557        match &self.join_operator {
558            JoinOperator::Inner(constraint) => write!(
559                f,
560                " {}JOIN {}{}",
561                prefix(constraint),
562                self.relation,
563                suffix(constraint)
564            ),
565            JoinOperator::LeftOuter(constraint) => write!(
566                f,
567                " {}LEFT JOIN {}{}",
568                prefix(constraint),
569                self.relation,
570                suffix(constraint)
571            ),
572            JoinOperator::RightOuter(constraint) => write!(
573                f,
574                " {}RIGHT JOIN {}{}",
575                prefix(constraint),
576                self.relation,
577                suffix(constraint)
578            ),
579            JoinOperator::FullOuter(constraint) => write!(
580                f,
581                " {}FULL JOIN {}{}",
582                prefix(constraint),
583                self.relation,
584                suffix(constraint)
585            ),
586            JoinOperator::CrossJoin => write!(f, " CROSS JOIN {}", self.relation),
587            JoinOperator::AsOfInner(constraint) => write!(
588                f,
589                " {}ASOF JOIN {}{}",
590                prefix(constraint),
591                self.relation,
592                suffix(constraint)
593            ),
594            JoinOperator::AsOfLeft(constraint) => write!(
595                f,
596                " {}ASOF LEFT JOIN {}{}",
597                prefix(constraint),
598                self.relation,
599                suffix(constraint)
600            ),
601        }
602    }
603}
604
605#[derive(Debug, Clone, PartialEq, Eq, Hash)]
606#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
607pub enum JoinOperator {
608    Inner(JoinConstraint),
609    LeftOuter(JoinConstraint),
610    RightOuter(JoinConstraint),
611    FullOuter(JoinConstraint),
612    CrossJoin,
613    AsOfInner(JoinConstraint),
614    AsOfLeft(JoinConstraint),
615}
616
617#[derive(Debug, Clone, PartialEq, Eq, Hash)]
618#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
619pub enum JoinConstraint {
620    On(Expr),
621    Using(Vec<Ident>),
622    Natural,
623    None,
624}
625
626/// An `ORDER BY` expression
627#[derive(Debug, Clone, PartialEq, Eq, Hash)]
628#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
629pub struct OrderByExpr {
630    pub expr: Expr,
631    /// Optional `ASC` or `DESC`
632    pub asc: Option<bool>,
633    /// Optional `NULLS FIRST` or `NULLS LAST`
634    pub nulls_first: Option<bool>,
635}
636
637impl fmt::Display for OrderByExpr {
638    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
639        write!(f, "{}", self.expr)?;
640        match self.asc {
641            Some(true) => write!(f, " ASC")?,
642            Some(false) => write!(f, " DESC")?,
643            None => (),
644        }
645        match self.nulls_first {
646            Some(true) => write!(f, " NULLS FIRST")?,
647            Some(false) => write!(f, " NULLS LAST")?,
648            None => (),
649        }
650        Ok(())
651    }
652}
653
654#[derive(Debug, Clone, PartialEq, Eq, Hash)]
655#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
656pub struct Fetch {
657    pub with_ties: bool,
658    pub quantity: Option<String>,
659}
660
661impl fmt::Display for Fetch {
662    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
663        let extension = if self.with_ties { "WITH TIES" } else { "ONLY" };
664        if let Some(ref quantity) = self.quantity {
665            write!(f, "FETCH FIRST {} ROWS {}", quantity, extension)
666        } else {
667            write!(f, "FETCH FIRST ROWS {}", extension)
668        }
669    }
670}
671
672#[derive(Debug, Clone, PartialEq, Eq, Hash)]
673#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
674pub struct Top {
675    /// SQL semantic equivalent of LIMIT but with same structure as FETCH.
676    pub with_ties: bool,
677    pub percent: bool,
678    pub quantity: Option<Expr>,
679}
680
681impl fmt::Display for Top {
682    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
683        let extension = if self.with_ties { " WITH TIES" } else { "" };
684        if let Some(ref quantity) = self.quantity {
685            let percent = if self.percent { " PERCENT" } else { "" };
686            write!(f, "TOP ({}){}{}", quantity, percent, extension)
687        } else {
688            write!(f, "TOP{}", extension)
689        }
690    }
691}
692
693#[derive(Debug, Clone, PartialEq, Eq, Hash)]
694#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
695pub struct Values(pub Vec<Vec<Expr>>);
696
697impl fmt::Display for Values {
698    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
699        write!(f, "VALUES ")?;
700        let mut delim = "";
701        for row in &self.0 {
702            write!(f, "{}", delim)?;
703            delim = ", ";
704            write!(f, "({})", display_comma_separated(row))?;
705        }
706        Ok(())
707    }
708}
risingwave_sqlparser/ast/query.rs

risingwave_sqlparser/ast/
query.rs
