diff --git a/src/sql-lexer/src/keywords.rs b/src/sql-lexer/src/keywords.rs index ac1f70f9a3d0b..412878ba64ffe 100644 --- a/src/sql-lexer/src/keywords.rs +++ b/src/sql-lexer/src/keywords.rs @@ -65,7 +65,7 @@ impl Keyword { matches!( self, // Keywords that can appear at the top-level of a SELECT statement. - WITH | SELECT | FROM | WHERE | GROUP | HAVING | ORDER | LIMIT | OFFSET | FETCH | OPTIONS | RETURNING | + WITH | SELECT | FROM | WHERE | GROUP | HAVING | QUALIFY | ORDER | LIMIT | OFFSET | FETCH | OPTIONS | RETURNING | // Set operations. UNION | EXCEPT | INTERSECT ) diff --git a/src/sql-lexer/src/keywords.txt b/src/sql-lexer/src/keywords.txt index 7c298f5229b7b..d58bf1815a484 100644 --- a/src/sql-lexer/src/keywords.txt +++ b/src/sql-lexer/src/keywords.txt @@ -341,6 +341,7 @@ Protocol Public Publication Pushdown +Qualify Query Quote Raise diff --git a/src/sql-parser/src/ast/defs/query.rs b/src/sql-parser/src/ast/defs/query.rs index a90332879d459..969454a77db1a 100644 --- a/src/sql-parser/src/ast/defs/query.rs +++ b/src/sql-parser/src/ast/defs/query.rs @@ -244,6 +244,8 @@ pub struct Select { pub group_by: Vec>, /// HAVING pub having: Option>, + /// QUALIFY + pub qualify: Option>, /// OPTION pub options: Vec>, } @@ -275,6 +277,10 @@ impl AstDisplay for Select { f.write_str(" HAVING "); f.write_node(having); } + if let Some(ref qualify) = self.qualify { + f.write_str(" QUALIFY "); + f.write_node(qualify); + } if !self.options.is_empty() { f.write_str(" OPTIONS ("); f.write_node(&display::comma_separated(&self.options)); diff --git a/src/sql-parser/src/parser.rs b/src/sql-parser/src/parser.rs index ba4224f929ba0..86cfb96f3fe3c 100644 --- a/src/sql-parser/src/parser.rs +++ b/src/sql-parser/src/parser.rs @@ -3766,6 +3766,7 @@ impl<'a> Parser<'a> { projection: vec![SelectItem::Wildcard], group_by: Vec::new(), having: None, + qualify: None, options: Vec::new(), })), order_by: Vec::new(), @@ -7479,6 +7480,12 @@ impl<'a> Parser<'a> { None }; + let qualify = if self.parse_keyword(QUALIFY) { + Some(self.parse_expr()?) + } else { + None + }; + let options = if self.parse_keyword(OPTIONS) { self.expect_token(&Token::LParen)?; let options = self.parse_comma_separated(Self::parse_select_option)?; @@ -7495,6 +7502,7 @@ impl<'a> Parser<'a> { selection, group_by, having, + qualify, options, }) } diff --git a/src/sql-parser/tests/testdata/alias b/src/sql-parser/tests/testdata/alias index bfc869ca7c1d2..9642ef8b69544 100644 --- a/src/sql-parser/tests/testdata/alias +++ b/src/sql-parser/tests/testdata/alias @@ -18,14 +18,14 @@ SELECT 'x' AS val ---- SELECT 'x' AS val => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("val")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("val")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT 'x' val ---- SELECT 'x' AS val => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("val")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("val")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT 'x' year @@ -39,32 +39,32 @@ SELECT 'x' AS year ---- SELECT 'x' AS "year" => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("year")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("year")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT 'x' "year" ---- SELECT 'x' AS "year" => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("year")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("x")), alias: Some(Ident("year")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT INTERVAL 'x' YEAR ---- SELECT INTERVAL 'x' YEAR => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Interval(IntervalValue { value: "x", precision_high: Year, precision_low: Year, fsec_max_precision: None })), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Interval(IntervalValue { value: "x", precision_high: Year, precision_low: Year, fsec_max_precision: None })), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT year ---- SELECT "year" => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("year")]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("year")]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT year FROM year ---- SELECT "year" FROM "year" => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("year")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("year")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("year")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("year")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) diff --git a/src/sql-parser/tests/testdata/continual-task b/src/sql-parser/tests/testdata/continual-task index 5b5523c38554f..80266bc46249d 100644 --- a/src/sql-parser/tests/testdata/continual-task +++ b/src/sql-parser/tests/testdata/continual-task @@ -26,7 +26,7 @@ CREATE CONTINUAL TASK foo (key int, val int) ON INPUT append_only AS ( ---- CREATE CONTINUAL TASK foo (key int4, val int4) ON INPUT append_only AS (DELETE FROM output WHERE key IN (SELECT key FROM inserts); INSERT INTO output SELECT key, max(value) FROM inserts GROUP BY key) => -CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: Some([CteMutRecColumnDef { name: Ident("key"), data_type: Other { name: Name(UnresolvedItemName([Ident("int4")])), typ_mod: [] } }, CteMutRecColumnDef { name: Ident("val"), data_type: Other { name: Name(UnresolvedItemName([Ident("int4")])), typ_mod: [] } }]), in_cluster: None, as_of: None, with_options: [], input: Name(UnresolvedItemName([Ident("append_only")])), stmts: [Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("output")])), alias: None, using: [], selection: Some(InSubquery { expr: Identifier([Ident("key")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("inserts")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }) }), Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("output")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("max")])), args: Args { args: [Identifier([Ident("value")])], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("inserts")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("key")])], having: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: None }) +CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: Some([CteMutRecColumnDef { name: Ident("key"), data_type: Other { name: Name(UnresolvedItemName([Ident("int4")])), typ_mod: [] } }, CteMutRecColumnDef { name: Ident("val"), data_type: Other { name: Name(UnresolvedItemName([Ident("int4")])), typ_mod: [] } }]), in_cluster: None, as_of: None, with_options: [], input: Name(UnresolvedItemName([Ident("append_only")])), stmts: [Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("output")])), alias: None, using: [], selection: Some(InSubquery { expr: Identifier([Ident("key")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("inserts")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }) }), Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("output")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("max")])), args: Args { args: [Identifier([Ident("value")])], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("inserts")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("key")])], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: None }) # Optional columns parse-statement @@ -67,21 +67,21 @@ CREATE CONTINUAL TASK "materialize"."public"."upsert" ("key" [s20 AS "pg_catalog ---- CREATE CONTINUAL TASK materialize.public.upsert (key [s20 AS pg_catalog.int4], val [s20 AS pg_catalog.int4]) IN CLUSTER [u1] ON INPUT [u1 AS materialize.public.append_only] AS (DELETE FROM materialize.public.upsert WHERE key IN (SELECT key FROM [u1 AS materialize.public.append_only]); INSERT INTO materialize.public.upsert SELECT key, pg_catalog.max(val) FROM [u1 AS materialize.public.append_only] GROUP BY key) AS OF 4 => -CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), columns: Some([CteMutRecColumnDef { name: Ident("key"), data_type: Other { name: Id("s20", UnresolvedItemName([Ident("pg_catalog"), Ident("int4")]), None), typ_mod: [] } }, CteMutRecColumnDef { name: Ident("val"), data_type: Other { name: Id("s20", UnresolvedItemName([Ident("pg_catalog"), Ident("int4")]), None), typ_mod: [] } }]), in_cluster: Some(Resolved("u1")), as_of: Some(4), with_options: [], input: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), stmts: [Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), alias: None, using: [], selection: Some(InSubquery { expr: Identifier([Ident("key")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }) }), Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("pg_catalog"), Ident("max")])), args: Args { args: [Identifier([Ident("val")])], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("key")])], having: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: None }) +CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), columns: Some([CteMutRecColumnDef { name: Ident("key"), data_type: Other { name: Id("s20", UnresolvedItemName([Ident("pg_catalog"), Ident("int4")]), None), typ_mod: [] } }, CteMutRecColumnDef { name: Ident("val"), data_type: Other { name: Id("s20", UnresolvedItemName([Ident("pg_catalog"), Ident("int4")]), None), typ_mod: [] } }]), in_cluster: Some(Resolved("u1")), as_of: Some(4), with_options: [], input: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), stmts: [Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), alias: None, using: [], selection: Some(InSubquery { expr: Identifier([Ident("key")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }) }), Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("upsert")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("key")]), alias: None }, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("pg_catalog"), Ident("max")])), args: Args { args: [Identifier([Ident("val")])], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("append_only")]), None), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("key")])], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: None }) parse-statement CREATE CONTINUAL TASK foo IN CLUSTER c WITH (SNAPSHOT = false) FROM TRANSFORM bar USING (SELECT baz::TIMESTAMPTZ FROM bar WHERE baz); ---- CREATE CONTINUAL TASK foo IN CLUSTER c WITH (SNAPSHOT = false) FROM TRANSFORM bar USING (SELECT baz::timestamptz FROM bar WHERE baz) => -CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: None, in_cluster: Some(Unresolved(Ident("c"))), as_of: None, with_options: [ContinualTaskOption { name: Snapshot, value: Some(Value(Boolean(false))) }], input: Name(UnresolvedItemName([Ident("bar")])), stmts: [Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Cast { expr: Identifier([Ident("baz")]), data_type: Other { name: Name(UnresolvedItemName([Ident("timestamptz")])), typ_mod: [] } }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Identifier([Ident("baz")])), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: Some(Transform { transform: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Cast { expr: Identifier([Ident("baz")]), data_type: Other { name: Name(UnresolvedItemName([Ident("timestamptz")])), typ_mod: [] } }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Identifier([Ident("baz")])), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }) }) +CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: None, in_cluster: Some(Unresolved(Ident("c"))), as_of: None, with_options: [ContinualTaskOption { name: Snapshot, value: Some(Value(Boolean(false))) }], input: Name(UnresolvedItemName([Ident("bar")])), stmts: [Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Cast { expr: Identifier([Ident("baz")]), data_type: Other { name: Name(UnresolvedItemName([Ident("timestamptz")])), typ_mod: [] } }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Identifier([Ident("baz")])), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] })], sugar: Some(Transform { transform: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Cast { expr: Identifier([Ident("baz")]), data_type: Other { name: Name(UnresolvedItemName([Ident("timestamptz")])), typ_mod: [] } }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Identifier([Ident("baz")])), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }) }) parse-statement CREATE CONTINUAL TASK foo IN CLUSTER c WITH (SNAPSHOT = false) FROM RETAIN bar WHILE (col + INTERVAL '1h' < mz_now()); ---- CREATE CONTINUAL TASK foo IN CLUSTER c WITH (SNAPSHOT = false) FROM RETAIN bar WHILE (col + INTERVAL '1h' < mz_now()) => -CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: None, in_cluster: Some(Unresolved(Ident("c"))), as_of: None, with_options: [ContinualTaskOption { name: Snapshot, value: Some(Value(Boolean(false))) }], input: Name(UnresolvedItemName([Ident("bar")])), stmts: [Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] }), Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), alias: None, using: [], selection: Some(Not { expr: Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) } }) })], sugar: Some(Retain { retain: Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) } }) }) +CreateContinualTask(CreateContinualTaskStatement { name: Name(UnresolvedItemName([Ident("foo")])), columns: None, in_cluster: Some(Unresolved(Ident("c"))), as_of: None, with_options: [ContinualTaskOption { name: Snapshot, value: Some(Value(Boolean(false))) }], input: Name(UnresolvedItemName([Ident("bar")])), stmts: [Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), columns: [], source: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), returning: [] }), Delete(DeleteStatement { table_name: Name(UnresolvedItemName([Ident("foo")])), alias: None, using: [], selection: Some(Not { expr: Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) } }) })], sugar: Some(Retain { retain: Op { op: Op { namespace: None, op: "<" }, expr1: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("col")]), expr2: Some(Value(Interval(IntervalValue { value: "1h", precision_high: Year, precision_low: Second, fsec_max_precision: None }))) }, expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false })) } }) }) parse-statement SHOW CONTINUAL TASKS; diff --git a/src/sql-parser/tests/testdata/copy b/src/sql-parser/tests/testdata/copy index f32e111b42c09..6cc286f74e709 100644 --- a/src/sql-parser/tests/testdata/copy +++ b/src/sql-parser/tests/testdata/copy @@ -32,14 +32,14 @@ COPY (select 1) TO STDOUT ---- COPY (SELECT 1) TO STDOUT => -Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Stdout, options: [] }) +Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Stdout, options: [] }) parse-statement COPY (subscribe (SELECT 1)) TO STDOUT ---- COPY (SUBSCRIBE (SELECT 1)) TO STDOUT => -Copy(CopyStatement { relation: Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: Diffs }), direction: To, target: Stdout, options: [] }) +Copy(CopyStatement { relation: Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: Diffs }), direction: To, target: Stdout, options: [] }) parse-statement COPY t(a, b) TO STDOUT @@ -140,14 +140,14 @@ COPY (select * from t) TO 's3://path/' || repeat('1', 2) ---- COPY (SELECT * FROM t) TO 's3://path/' || repeat('1', 2) => -Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Op { op: Op { namespace: None, op: "||" }, expr1: Value(String("s3://path/")), expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("repeat")])), args: Args { args: [Value(String("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false })) }), options: [] }) +Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Op { op: Op { namespace: None, op: "||" }, expr1: Value(String("s3://path/")), expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("repeat")])), args: Args { args: [Value(String("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false })) }), options: [] }) parse-statement COPY (select *, mz_now() from t) TO 's3://path/' ---- COPY (SELECT *, mz_now() FROM t) TO 's3://path/' => -Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Value(String("s3://path/"))), options: [] }) +Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard, Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Value(String("s3://path/"))), options: [] }) parse-statement @@ -169,7 +169,7 @@ COPY (select * from t order by 1) TO 's3://path/' || repeat('1', 2) ---- COPY (SELECT * FROM t ORDER BY 1) TO 's3://path/' || repeat('1', 2) => -Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Value(Number("1")), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Op { op: Op { namespace: None, op: "||" }, expr1: Value(String("s3://path/")), expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("repeat")])), args: Args { args: [Value(String("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false })) }), options: [] }) +Copy(CopyStatement { relation: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Value(Number("1")), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }), direction: To, target: Expr(Op { op: Op { namespace: None, op: "||" }, expr1: Value(String("s3://path/")), expr2: Some(Function(Function { name: Name(UnresolvedItemName([Ident("repeat")])), args: Args { args: [Value(String("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false })) }), options: [] }) parse-statement COPY INTO t1 FROM STDIN diff --git a/src/sql-parser/tests/testdata/cursor b/src/sql-parser/tests/testdata/cursor index d5adcdb069ca3..c2ee50827a328 100644 --- a/src/sql-parser/tests/testdata/cursor +++ b/src/sql-parser/tests/testdata/cursor @@ -18,7 +18,7 @@ DECLARE "c" CURSOR WITHOUT HOLD FOR SELECT * FROM t ---- DECLARE c CURSOR FOR SELECT * FROM t => -Declare(DeclareStatement { name: Ident("c"), stmt: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), sql: "SELECT * FROM t" }) +Declare(DeclareStatement { name: Ident("c"), stmt: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), sql: "SELECT * FROM t" }) parse-statement DECLARE c CURSOR FOR SUBSCRIBE t diff --git a/src/sql-parser/tests/testdata/ddl b/src/sql-parser/tests/testdata/ddl index 08449bab89267..ce209e4eca4de 100644 --- a/src/sql-parser/tests/testdata/ddl +++ b/src/sql-parser/tests/testdata/ddl @@ -367,35 +367,35 @@ CREATE VIEW myschema.myview AS SELECT foo FROM bar ---- CREATE VIEW myschema.myview AS SELECT foo FROM bar => -CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE TEMPORARY VIEW myview AS SELECT foo FROM bar ---- CREATE TEMPORARY VIEW myview AS SELECT foo FROM bar => -CreateView(CreateViewStatement { if_exists: Error, temporary: true, definition: ViewDefinition { name: UnresolvedItemName([Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: true, definition: ViewDefinition { name: UnresolvedItemName([Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE TEMP VIEW myview AS SELECT foo FROM bar ---- CREATE TEMPORARY VIEW myview AS SELECT foo FROM bar => -CreateView(CreateViewStatement { if_exists: Error, temporary: true, definition: ViewDefinition { name: UnresolvedItemName([Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: true, definition: ViewDefinition { name: UnresolvedItemName([Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE OR REPLACE VIEW v AS SELECT 1 ---- CREATE OR REPLACE VIEW v AS SELECT 1 => -CreateView(CreateViewStatement { if_exists: Replace, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Replace, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE VIEW IF NOT EXISTS v AS SELECT 1 ---- CREATE VIEW IF NOT EXISTS v AS SELECT 1 => -CreateView(CreateViewStatement { if_exists: Skip, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Skip, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE OR REPLACE VIEW IF NOT EXISTS v AS SELECT 1 @@ -409,70 +409,70 @@ CREATE VIEW v (has, cols) AS SELECT 1, 2 ---- CREATE VIEW v (has, cols) AS SELECT 1, 2 => -CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [Ident("has"), Ident("cols")], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }, Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [Ident("has"), Ident("cols")], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }, Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE VIEW IF NOT EXISTS myschema.myview AS SELECT foo FROM bar ---- CREATE VIEW IF NOT EXISTS myschema.myview AS SELECT foo FROM bar => -CreateView(CreateViewStatement { if_exists: Skip, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Skip, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE MATERIALIZED VIEW myschema.myview AS SELECT foo FROM bar ---- CREATE MATERIALIZED VIEW myschema.myview AS SELECT foo FROM bar => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("myschema"), Ident("myview")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE OR REPLACE MATERIALIZED VIEW v AS SELECT 1 ---- CREATE OR REPLACE MATERIALIZED VIEW v AS SELECT 1 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Replace, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Replace, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE MATERIALIZED VIEW IF NOT EXISTS v AS SELECT 1 ---- CREATE MATERIALIZED VIEW IF NOT EXISTS v AS SELECT 1 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Skip, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Skip, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE MATERIALIZED VIEW v (has, cols) AS SELECT 1, 2 ---- CREATE MATERIALIZED VIEW v (has, cols) AS SELECT 1, 2 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("has"), Ident("cols")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }, Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("has"), Ident("cols")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }, Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE MATERIALIZED VIEW v IN CLUSTER bar AS SELECT 1 ---- CREATE MATERIALIZED VIEW v IN CLUSTER bar AS SELECT 1 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Unresolved(Ident("bar"))), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Unresolved(Ident("bar"))), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE MATERIALIZED VIEW v IN CLUSTER [1] AS SELECT 1 ---- CREATE MATERIALIZED VIEW v IN CLUSTER [1] AS SELECT 1 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Resolved("1")), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Resolved("1")), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }) parse-statement CREATE MATERIALIZED VIEW v (n) WITH (PARTITION BY (n)) AS SELECT 1 ---- CREATE MATERIALIZED VIEW v (n) WITH (PARTITION BY = (n)) AS SELECT 1 => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("n")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: PartitionBy, value: Some(Sequence([UnresolvedItemName(UnresolvedItemName([Ident("n")]))])) }] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("n")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: PartitionBy, value: Some(Sequence([UnresolvedItemName(UnresolvedItemName([Ident("n")]))])) }] }) parse-statement CREATE MATERIALIZED VIEW v (n, m) WITH (PARTITION BY (n, m)) AS SELECT (1, 2); ---- CREATE MATERIALIZED VIEW v (n, m) WITH (PARTITION BY = (n, m)) AS SELECT ROW(1, 2) => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("n"), Ident("m")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Row { exprs: [Value(Number("1")), Value(Number("2"))] }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: PartitionBy, value: Some(Sequence([UnresolvedItemName(UnresolvedItemName([Ident("n")])), UnresolvedItemName(UnresolvedItemName([Ident("m")]))])) }] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [Ident("n"), Ident("m")], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Row { exprs: [Value(Number("1")), Value(Number("2"))] }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: PartitionBy, value: Some(Sequence([UnresolvedItemName(UnresolvedItemName([Ident("n")])), UnresolvedItemName(UnresolvedItemName([Ident("m")]))])) }] }) parse-statement @@ -480,14 +480,14 @@ CREATE MATERIALIZED VIEW v WITH (REFRESH EVERY '1 day', ASSERT NOT NULL x) AS SE ---- CREATE MATERIALIZED VIEW v WITH (REFRESH = EVERY '1 day', ASSERT NOT NULL = x) AS SELECT * FROM t => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: Refresh, value: Some(Refresh(Every(RefreshEveryOptionValue { interval: IntervalValue { value: "1 day", precision_high: Year, precision_low: Second, fsec_max_precision: None }, aligned_to: None }))) }, MaterializedViewOption { name: AssertNotNull, value: Some(UnresolvedItemName(UnresolvedItemName([Ident("x")]))) }] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: Refresh, value: Some(Refresh(Every(RefreshEveryOptionValue { interval: IntervalValue { value: "1 day", precision_high: Year, precision_low: Second, fsec_max_precision: None }, aligned_to: None }))) }, MaterializedViewOption { name: AssertNotNull, value: Some(UnresolvedItemName(UnresolvedItemName([Ident("x")]))) }] }) parse-statement CREATE OR REPLACE MATERIALIZED VIEW v IN CLUSTER [1] WITH (REFRESH EVERY '1 day' ALIGNED TO '2023-12-11 11:00', ASSERT NOT NULL x, REFRESH AT mz_now(), REFRESH ON COMMIT, REFRESH = AT CREATION) AS SELECT * FROM t; ---- CREATE OR REPLACE MATERIALIZED VIEW v IN CLUSTER [1] WITH (REFRESH = EVERY '1 day' ALIGNED TO '2023-12-11 11:00', ASSERT NOT NULL = x, REFRESH = AT mz_now(), REFRESH = ON COMMIT, REFRESH = AT CREATION) AS SELECT * FROM t => -CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Replace, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Resolved("1")), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: Refresh, value: Some(Refresh(Every(RefreshEveryOptionValue { interval: IntervalValue { value: "1 day", precision_high: Year, precision_low: Second, fsec_max_precision: None }, aligned_to: Some(Value(String("2023-12-11 11:00"))) }))) }, MaterializedViewOption { name: AssertNotNull, value: Some(UnresolvedItemName(UnresolvedItemName([Ident("x")]))) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(At(RefreshAtOptionValue { time: Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }) }))) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(OnCommit)) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(AtCreation)) }] }) +CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Replace, name: UnresolvedItemName([Ident("v")]), columns: [], in_cluster: Some(Resolved("1")), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [MaterializedViewOption { name: Refresh, value: Some(Refresh(Every(RefreshEveryOptionValue { interval: IntervalValue { value: "1 day", precision_high: Year, precision_low: Second, fsec_max_precision: None }, aligned_to: Some(Value(String("2023-12-11 11:00"))) }))) }, MaterializedViewOption { name: AssertNotNull, value: Some(UnresolvedItemName(UnresolvedItemName([Ident("x")]))) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(At(RefreshAtOptionValue { time: Function(Function { name: Name(UnresolvedItemName([Ident("mz_now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }) }))) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(OnCommit)) }, MaterializedViewOption { name: Refresh, value: Some(Refresh(AtCreation)) }] }) parse-statement roundtrip CREATE OR REPLACE MATERIALIZED VIEW v WITH (ASSERT NOT NULL a, ASSERT NOT NULL = b, RETAIN HISTORY = FOR '1s') AS SELECT 1 @@ -933,7 +933,7 @@ CREATE INDEX fizz ON baz (ascii(x), a IS NOT NULL, (EXISTS (SELECT y FROM boop W ---- CREATE INDEX fizz ON baz (ascii(x), a IS NOT NULL, (EXISTS (SELECT y FROM boop WHERE boop.z = z)), delta) => -CreateIndex(CreateIndexStatement { name: Some(Ident("fizz")), in_cluster: None, on_name: Name(UnresolvedItemName([Ident("baz")])), key_parts: Some([Function(Function { name: Name(UnresolvedItemName([Ident("ascii")])), args: Args { args: [Identifier([Ident("x")])], order_by: [] }, filter: None, over: None, distinct: false }), IsExpr { expr: Identifier([Ident("a")]), construct: Null, negated: true }, Nested(Exists(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("y")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("boop")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("boop"), Ident("z")]), expr2: Some(Identifier([Ident("z")])) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None })), Identifier([Ident("delta")])]), with_options: [], if_not_exists: false }) +CreateIndex(CreateIndexStatement { name: Some(Ident("fizz")), in_cluster: None, on_name: Name(UnresolvedItemName([Ident("baz")])), key_parts: Some([Function(Function { name: Name(UnresolvedItemName([Ident("ascii")])), args: Args { args: [Identifier([Ident("x")])], order_by: [] }, filter: None, over: None, distinct: false }), IsExpr { expr: Identifier([Ident("a")]), construct: Null, negated: true }, Nested(Exists(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("y")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("boop")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("boop"), Ident("z")]), expr2: Some(Identifier([Ident("z")])) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None })), Identifier([Ident("delta")])]), with_options: [], if_not_exists: false }) parse-statement CREATE INDEX ind ON tab ((col + 1)) @@ -1199,7 +1199,7 @@ SUBSCRIBE (SELECT * FROM a) ---- SUBSCRIBE (SELECT * FROM a) => -Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: Diffs }) +Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: Diffs }) parse-statement SUBSCRIBE foo.bar AS OF now() UP TO now() + interval '1' day @@ -1298,7 +1298,7 @@ SUBSCRIBE (SELECT *, f1 + f2 FROM foo.bar) WITHIN TIMESTAMP ORDER BY foo.bar.baz ---- SUBSCRIBE (SELECT *, f1 + f2 FROM foo.bar) WITHIN TIMESTAMP ORDER BY foo.bar.baz DESC, f1 + f2 => -Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard, Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("f1")]), expr2: Some(Identifier([Ident("f2")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo"), Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: WithinTimestampOrderBy { order_by: [OrderByExpr { expr: Identifier([Ident("foo"), Ident("bar"), Ident("baz")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("f1")]), expr2: Some(Identifier([Ident("f2")])) }, asc: None, nulls_last: None }] } }) +Subscribe(SubscribeStatement { relation: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard, Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("f1")]), expr2: Some(Identifier([Ident("f2")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo"), Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), options: [], as_of: None, up_to: None, output: WithinTimestampOrderBy { order_by: [OrderByExpr { expr: Identifier([Ident("foo"), Ident("bar"), Ident("baz")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("f1")]), expr2: Some(Identifier([Ident("f2")])) }, asc: None, nulls_last: None }] } }) parse-statement diff --git a/src/sql-parser/tests/testdata/error b/src/sql-parser/tests/testdata/error index 508009132122b..1aeb15d21afcf 100644 --- a/src/sql-parser/tests/testdata/error +++ b/src/sql-parser/tests/testdata/error @@ -107,7 +107,7 @@ SELECT 1 WHERE 1 + ANY (SELECT 2) ---- SELECT 1 WHERE 1 + ANY (SELECT 2) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: Some(AnySubquery { left: Value(Number("1")), op: Op { namespace: None, op: "+" }, right: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: Some(AnySubquery { left: Value(Number("1")), op: Op { namespace: None, op: "+" }, right: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT EXISTS (NULL) diff --git a/src/sql-parser/tests/testdata/explain b/src/sql-parser/tests/testdata/explain index ab4a27ae87833..f88c19311f4fa 100644 --- a/src/sql-parser/tests/testdata/explain +++ b/src/sql-parser/tests/testdata/explain @@ -23,42 +23,42 @@ EXPLAIN SELECT 665 ---- EXPLAIN SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN RAW PLAN FOR SELECT 665 ---- EXPLAIN RAW PLAN FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(RawPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(RawPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN DECORRELATED PLAN FOR SELECT 665 ---- EXPLAIN DECORRELATED PLAN FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(DecorrelatedPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(DecorrelatedPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR SELECT 665 ---- EXPLAIN OPTIMIZED PLAN FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(GlobalPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(GlobalPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN PHYSICAL PLAN FOR SELECT 665 ---- EXPLAIN PHYSICAL PLAN FOR SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(PhysicalPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(PhysicalPlan), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN SELECT 665 ---- EXPLAIN SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZED PLAN FOR VIEW foo @@ -149,14 +149,14 @@ EXPLAIN ((SELECT 1)) ---- EXPLAIN SELECT 1 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZED PLAN AS TEXT FOR WITH a AS (SELECT 1) SELECT * FROM a ---- EXPLAIN OPTIMIZED PLAN AS TEXT FOR WITH a AS (SELECT 1) SELECT * FROM a => -ExplainPlan(ExplainPlanStatement { stage: Some(GlobalPlan), with_options: [], format: Some(Text), explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(GlobalPlan), with_options: [], format: Some(Text), explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) # regression test for database-issues#4624 parse-statement @@ -164,56 +164,56 @@ EXPLAIN WITH a AS (SELECT 1) SELECT * FROM a ---- EXPLAIN WITH a AS (SELECT 1) SELECT * FROM a => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN TIMESTAMP FOR SELECT 1 ---- EXPLAIN TIMESTAMP FOR SELECT 1 => -ExplainTimestamp(ExplainTimestampStatement { format: None, select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) +ExplainTimestamp(ExplainTimestampStatement { format: None, select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) parse-statement EXPLAIN TIMESTAMP AS TEXT FOR SELECT 1 ---- EXPLAIN TIMESTAMP AS TEXT FOR SELECT 1 => -ExplainTimestamp(ExplainTimestampStatement { format: Some(Text), select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) +ExplainTimestamp(ExplainTimestampStatement { format: Some(Text), select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) parse-statement EXPLAIN TIMESTAMP AS JSON FOR SELECT 1 ---- EXPLAIN TIMESTAMP AS JSON FOR SELECT 1 => -ExplainTimestamp(ExplainTimestampStatement { format: Some(Json), select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) +ExplainTimestamp(ExplainTimestampStatement { format: Some(Json), select: SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None } }) parse-statement EXPLAIN AS JSON SELECT * FROM foo ---- EXPLAIN AS JSON SELECT * FROM foo => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: Some(Json), explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: Some(Json), explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN OPTIMIZER TRACE WITH (types) AS TEXT FOR BROKEN SELECT 1 + 1 ---- EXPLAIN OPTIMIZER TRACE WITH (TYPES) AS TEXT FOR BROKEN SELECT 1 + 1 => -ExplainPlan(ExplainPlanStatement { stage: Some(Trace), with_options: [ExplainPlanOption { name: Types, value: None }], format: Some(Text), explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, true) }) +ExplainPlan(ExplainPlanStatement { stage: Some(Trace), with_options: [ExplainPlanOption { name: Types, value: None }], format: Some(Text), explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, true) }) parse-statement EXPLAIN LOCALLY OPTIMIZED PLAN FOR CREATE VIEW mv AS SELECT 665 ---- EXPLAIN LOCALLY OPTIMIZED PLAN FOR CREATE VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(LocalPlan), with_options: [], format: None, explainee: CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(LocalPlan), with_options: [], format: None, explainee: CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) parse-statement EXPLAIN LOCALLY OPTIMIZED PLAN FOR CREATE OR REPLACE VIEW mv AS SELECT 665 ---- EXPLAIN LOCALLY OPTIMIZED PLAN FOR CREATE OR REPLACE VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: Some(LocalPlan), with_options: [], format: None, explainee: CreateView(CreateViewStatement { if_exists: Replace, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(LocalPlan), with_options: [], format: None, explainee: CreateView(CreateViewStatement { if_exists: Replace, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("mv")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }, false) }) parse-statement EXPLAIN CREATE VIEW mv AS SELECT 665 @@ -227,14 +227,14 @@ EXPLAIN WITH (humanized expressions) CREATE MATERIALIZED VIEW mv AS SELECT 665 ---- EXPLAIN WITH (HUMANIZED EXPRESSIONS) CREATE MATERIALIZED VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [ExplainPlanOption { name: HumanizedExpressions, value: None }], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [ExplainPlanOption { name: HumanizedExpressions, value: None }], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) parse-statement EXPLAIN BROKEN CREATE MATERIALIZED VIEW mv AS SELECT 665 ---- EXPLAIN BROKEN CREATE MATERIALIZED VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, true) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, true) }) parse-statement EXPLAIN BROKEN CREATE DEFAULT INDEX ON q1 @@ -283,21 +283,21 @@ EXPLAIN SELECT 665 AS OF 3 ---- EXPLAIN SELECT 665 AS OF 3 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("3")))) }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("3")))) }, false) }) parse-statement EXPLAIN FILTER PUSHDOWN FOR SELECT * FROM numbers where value > 10 ---- EXPLAIN FILTER PUSHDOWN FOR SELECT * FROM numbers WHERE value > 10 => -ExplainPushdown(ExplainPushdownStatement { explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("numbers")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Identifier([Ident("value")]), expr2: Some(Value(Number("10"))) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPushdown(ExplainPushdownStatement { explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("numbers")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Identifier([Ident("value")]), expr2: Some(Value(Number("10"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN PLAN INSIGHTS FOR SELECT 1 ---- EXPLAIN PLAN INSIGHTS FOR SELECT 1 => -ExplainPlan(ExplainPlanStatement { stage: Some(PlanInsights), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) +ExplainPlan(ExplainPlanStatement { stage: Some(PlanInsights), with_options: [], format: None, explainee: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }, false) }) parse-statement EXPLAIN FILTER PUSHDOWN FOR MATERIALIZED VIEW whatever @@ -311,4 +311,4 @@ EXPLAIN WITH (ARITY, EQUIVALENCES, HUMANIZED EXPRESSIONS) CREATE MATERIALIZED VI ---- EXPLAIN WITH (ARITY, EQUIVALENCES, HUMANIZED EXPRESSIONS) CREATE MATERIALIZED VIEW mv AS SELECT 665 => -ExplainPlan(ExplainPlanStatement { stage: None, with_options: [ExplainPlanOption { name: Arity, value: None }, ExplainPlanOption { name: Equivalences, value: None }, ExplainPlanOption { name: HumanizedExpressions, value: None }], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) +ExplainPlan(ExplainPlanStatement { stage: None, with_options: [ExplainPlanOption { name: Arity, value: None }, ExplainPlanOption { name: Equivalences, value: None }, ExplainPlanOption { name: HumanizedExpressions, value: None }], format: None, explainee: CreateMaterializedView(CreateMaterializedViewStatement { if_exists: Error, name: UnresolvedItemName([Ident("mv")]), columns: [], in_cluster: None, query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("665")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None, with_options: [] }, false) }) diff --git a/src/sql-parser/tests/testdata/id b/src/sql-parser/tests/testdata/id index d7fc3cbf32d13..f4a0afc83fafa 100644 --- a/src/sql-parser/tests/testdata/id +++ b/src/sql-parser/tests/testdata/id @@ -18,14 +18,14 @@ SELECT * FROM [u123 AS materialize.public.foo] ---- SELECT * FROM [u123 AS materialize.public.foo] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u123", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("foo")]), None), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u123", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("foo")]), None), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT [u123 AS materialize.public.foo](1) ---- SELECT [u123 AS materialize.public.foo](1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Id("u123", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("foo")]), None), args: Args { args: [Value(Number("1"))], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Id("u123", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("foo")]), None), args: Args { args: [Value(Number("1"))], order_by: [] }, filter: None, over: None, distinct: false }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM [u123 AS foo] @@ -53,14 +53,14 @@ CREATE VIEW v1 AS SELECT * FROM [ u1 as materialize.public.t1 VERSION 5] ---- CREATE VIEW v1 AS SELECT * FROM [u1 AS materialize.public.t1 VERSION 5] => -CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v1")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("t1")]), Some(Version(5))), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v1")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("t1")]), Some(Version(5))), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE VIEW "materialize"."public"."v3" AS SELECT * FROM [u1 AS "materialize"."public"."t1" VERSION 3] ---- CREATE VIEW materialize.public.v3 AS SELECT * FROM [u1 AS materialize.public.t1 VERSION 3] => -CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("v3")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("t1")]), Some(Version(3))), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("v3")]), columns: [], query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Id("u1", UnresolvedItemName([Ident("materialize"), Ident("public"), Ident("t1")]), Some(Version(3))), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement CREATE VIEW "materialize"."public"."v3" AS SELECT * FROM [u1 AS "materialize"."public"."t1" VERSION foobar] diff --git a/src/sql-parser/tests/testdata/insert b/src/sql-parser/tests/testdata/insert index 397d2680254f1..61da535fa7565 100644 --- a/src/sql-parser/tests/testdata/insert +++ b/src/sql-parser/tests/testdata/insert @@ -58,7 +58,7 @@ INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1) ---- INSERT INTO customer WITH foo AS (SELECT 1) SELECT * FROM foo UNION VALUES (1) => -Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("customer")])), columns: [], source: Query(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("foo"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: SetOperation { op: Union, all: false, left: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), right: Values(Values([[Value(Number("1"))]])) }, order_by: [], limit: None, offset: None }), returning: [] }) +Insert(InsertStatement { table_name: Name(UnresolvedItemName([Ident("customer")])), columns: [], source: Query(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("foo"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: SetOperation { op: Union, all: false, left: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), right: Values(Values([[Value(Number("1"))]])) }, order_by: [], limit: None, offset: None }), returning: [] }) parse-statement INSERT INTO customer DEFAULT VALUES diff --git a/src/sql-parser/tests/testdata/prepare b/src/sql-parser/tests/testdata/prepare index 10a863242d70e..2d7996795ffab 100644 --- a/src/sql-parser/tests/testdata/prepare +++ b/src/sql-parser/tests/testdata/prepare @@ -18,7 +18,7 @@ PREPARE a AS SELECT 1 + $1 ---- PREPARE a AS SELECT 1 + $1 => -Prepare(PrepareStatement { name: Ident("a"), stmt: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Parameter(1)) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), sql: "SELECT 1 + $1" }) +Prepare(PrepareStatement { name: Ident("a"), stmt: Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Parameter(1)) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }), sql: "SELECT 1 + $1" }) parse-statement EXECUTE a diff --git a/src/sql-parser/tests/testdata/scalar b/src/sql-parser/tests/testdata/scalar index f0b045e135620..ce1feed76fe14 100644 --- a/src/sql-parser/tests/testdata/scalar +++ b/src/sql-parser/tests/testdata/scalar @@ -581,7 +581,7 @@ Case { operand: Some(Identifier([Ident("foo")])), conditions: [Value(Number("1") parse-scalar (SELECT 1) + (SELECT 2) ---- -Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None })) } +Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None })) } parse-scalar roundtrip 1 < 2 @@ -656,7 +656,7 @@ Op { op: Op { namespace: Some([Ident("pg_catalog")]), op: "+" }, expr1: Value(Nu parse-scalar 1 < ANY (SELECT 2) ---- -AnySubquery { left: Value(Number("1")), op: Op { namespace: None, op: "<" }, right: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } +AnySubquery { left: Value(Number("1")), op: Op { namespace: None, op: "<" }, right: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } parse-scalar 1 < ANY (fn()) diff --git a/src/sql-parser/tests/testdata/select b/src/sql-parser/tests/testdata/select index 52cdf906ed18f..55a58bcbf91e4 100644 --- a/src/sql-parser/tests/testdata/select +++ b/src/sql-parser/tests/testdata/select @@ -33,7 +33,7 @@ parse-statement ---- SELECT 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT (((SELECT 2)) + 3) @@ -154,7 +154,7 @@ SELECT (SELECT) ---- SELECT (SELECT) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ) @@ -173,7 +173,7 @@ SELECT AS OF 0 ---- SELECT AS OF 0 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("0")))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("0")))) }) parse-statement roundtrip SELECT (1, 2) @@ -235,7 +235,7 @@ SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5 ---- SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT 5 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("1"))) }), group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("5")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("1"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("5")) }), offset: None }, as_of: None }) # LIMIT should not be parsed as an alias. @@ -244,35 +244,35 @@ SELECT id FROM customer LIMIT 1 ---- SELECT id FROM customer LIMIT 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) parse-statement SELECT 1 LIMIT 5 ---- SELECT 1 LIMIT 5 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("5")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("5")) }), offset: None }, as_of: None }) parse-statement SELECT DISTINCT name FROM customer ---- SELECT DISTINCT name FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(EntireRow), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(EntireRow), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT DISTINCT ON (a, b) name, a, b FROM customer ---- SELECT DISTINCT ON (a, b) name, a, b FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Identifier([Ident("a")]), Identifier([Ident("b")])])), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }, Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Identifier([Ident("a")]), Identifier([Ident("b")])])), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }, Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT DISTINCT ON (a, b) name, a, b FROM customer ---- SELECT DISTINCT ON (a, b) name, a, b FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Identifier([Ident("a")]), Identifier([Ident("b")])])), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }, Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Identifier([Ident("a")]), Identifier([Ident("b")])])), projection: [Expr { expr: Identifier([Ident("name")]), alias: None }, Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT DISTINCT ON (a, b) name, a, b FROM customer @@ -284,7 +284,7 @@ SELECT DISTINCT ON (a + b, NOT c) a, b, c FROM customer ---- SELECT DISTINCT ON (a + b, NOT c) a, b, c FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("a")]), expr2: Some(Identifier([Ident("b")])) }, Not { expr: Identifier([Ident("c")]) }])), projection: [Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }, Expr { expr: Identifier([Ident("c")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: Some(On([Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("a")]), expr2: Some(Identifier([Ident("b")])) }, Not { expr: Identifier([Ident("c")]) }])), projection: [Expr { expr: Identifier([Ident("a")]), alias: None }, Expr { expr: Identifier([Ident("b")]), alias: None }, Expr { expr: Identifier([Ident("c")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT ALL name FROM customer @@ -296,21 +296,21 @@ SELECT * FROM foo ---- SELECT * FROM foo => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT foo.* FROM foo ---- SELECT foo.* FROM foo => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: QualifiedWildcard([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: QualifiedWildcard([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT (x).a, (x).a.b.c ---- SELECT (x).a, (x).a.b.c => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: FieldAccess { expr: Nested(Identifier([Ident("x")])), field: Ident("a") }, alias: None }, Expr { expr: FieldAccess { expr: FieldAccess { expr: FieldAccess { expr: Nested(Identifier([Ident("x")])), field: Ident("a") }, field: Ident("b") }, field: Ident("c") }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: FieldAccess { expr: Nested(Identifier([Ident("x")])), field: Ident("a") }, alias: None }, Expr { expr: FieldAccess { expr: FieldAccess { expr: FieldAccess { expr: Nested(Identifier([Ident("x")])), field: Ident("a") }, field: Ident("b") }, field: Ident("c") }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT (1.a) @@ -324,7 +324,7 @@ SELECT (x).*.* ---- SELECT (x).*.* => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: WildcardAccess(WildcardAccess(Nested(Identifier([Ident("x")])))), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: WildcardAccess(WildcardAccess(Nested(Identifier([Ident("x")])))), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT count(employee.*) FROM "order" JOIN employee ON "order".employee = employee.id @@ -336,7 +336,7 @@ SELECT a.col + 1 AS newname FROM foo AS a ---- SELECT a.col + 1 AS newname FROM foo AS a => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("a"), Ident("col")]), expr2: Some(Value(Number("1"))) }, alias: Some(Ident("newname")) }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: Some(TableAlias { name: Ident("a"), columns: [], strict: false }) }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("a"), Ident("col")]), expr2: Some(Value(Number("1"))) }, alias: Some(Ident("newname")) }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("foo")])), alias: Some(TableAlias { name: Ident("a"), columns: [], strict: false }) }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT a.col + 1 AS newname FROM foo AS a @@ -378,14 +378,14 @@ SELECT count(*) FILTER (WHERE foo) FROM customer ---- SELECT count(*) FILTER (WHERE foo) FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: Some(Identifier([Ident("foo")])), over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: Some(Identifier([Ident("foo")])), over: None, distinct: false }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT count(DISTINCT + x) FROM customer ---- SELECT count(DISTINCT + x) FROM customer => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Args { args: [Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("x")]), expr2: None }], order_by: [] }, filter: None, over: None, distinct: true }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Args { args: [Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("x")]), expr2: None }], order_by: [] }, filter: None, over: None, distinct: true }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT count(ALL + x) FROM customer @@ -417,7 +417,7 @@ SELECT array_agg(b ORDER BY a) ---- SELECT array_agg(b ORDER BY a) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("array_agg")])), args: Args { args: [Identifier([Ident("b")])], order_by: [OrderByExpr { expr: Identifier([Ident("a")]), asc: None, nulls_last: None }] }, filter: None, over: None, distinct: false }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("array_agg")])), args: Args { args: [Identifier([Ident("b")])], order_by: [OrderByExpr { expr: Identifier([Ident("a")]), asc: None, nulls_last: None }] }, filter: None, over: None, distinct: false }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Parameters @@ -472,70 +472,70 @@ SELECT * FROM customers WHERE segment IN (SELECT segm FROM bar) ---- SELECT * FROM customers WHERE segment IN (SELECT segm FROM bar) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("segment")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("segm")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("segment")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("segm")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM customers WHERE segment NOT IN (SELECT segm FROM bar) ---- SELECT * FROM customers WHERE segment NOT IN (SELECT segm FROM bar) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("segment")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("segm")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, negated: true }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("segment")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("segm")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, negated: true }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN (VALUES (1)) ---- SELECT * FROM t WHERE x IN (VALUES (1)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Values(Values([[Value(Number("1"))]])), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Values(Values([[Value(Number("1"))]])), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x NOT IN (VALUES (1)) ---- SELECT * FROM t WHERE x NOT IN (VALUES (1)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Values(Values([[Value(Number("1"))]])), order_by: [], limit: None, offset: None }, negated: true }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Values(Values([[Value(Number("1"))]])), order_by: [], limit: None, offset: None }, negated: true }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN (TABLE t) ---- SELECT * FROM t WHERE x IN (TABLE t) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Table(Name(UnresolvedItemName([Ident("t")]))), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Table(Name(UnresolvedItemName([Ident("t")]))), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN (SHOW SOURCES) ---- SELECT * FROM t WHERE x IN (SHOW SOURCES) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Show(ShowObjects(ShowObjectsStatement { object_type: Source { in_cluster: None }, from: None, filter: None })), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Show(ShowObjects(ShowObjectsStatement { object_type: Source { in_cluster: None }, from: None, filter: None })), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN (((SELECT 1))) ---- SELECT * FROM t WHERE x IN (SELECT 1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN ((SELECT 1) UNION (SELECT 1)) ---- SELECT * FROM t WHERE x IN ((SELECT 1) UNION (SELECT 1)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InSubquery { expr: Identifier([Ident("x")]), subquery: Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None }, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ((SELECT 1) + 1, 2 + ((SELECT 1) UNION (SELECT 2 WHERE false))); ---- SELECT ROW((SELECT 1) + 1, 2 + ((SELECT 1) UNION (SELECT 2 WHERE false))) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Row { exprs: [Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Value(Number("1"))) }, Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Subquery(Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: Some(Value(Boolean(false))), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None })) }] }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Row { exprs: [Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Value(Number("1"))) }, Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Subquery(Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: Some(Value(Boolean(false))), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None })) }] }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN ((SELECT 1) + 1, 2 + ((SELECT 1) UNION (SELECT 2 WHERE false))); ---- SELECT * FROM t WHERE x IN ((SELECT 1) + 1, 2 + ((SELECT 1) UNION (SELECT 2 WHERE false))) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InList { expr: Identifier([Ident("x")]), list: [Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Value(Number("1"))) }, Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Subquery(Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: Some(Value(Boolean(false))), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None })) }], negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(InList { expr: Identifier([Ident("x")]), list: [Op { op: Op { namespace: None, op: "+" }, expr1: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), expr2: Some(Value(Number("1"))) }, Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Subquery(Query { ctes: Simple([]), body: SetOperation { op: Union, all: false, left: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), right: Query(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: None }], from: [], selection: Some(Value(Boolean(false))), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }) }, order_by: [], limit: None, offset: None })) }], negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE x IN (((SELECT 1)) AND false @@ -549,28 +549,28 @@ SELECT * FROM customers WHERE age BETWEEN 25 AND 32 ---- SELECT * FROM customers WHERE age BETWEEN 25 AND 32 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(Between { expr: Identifier([Ident("age")]), negated: false, low: Value(Number("25")), high: Value(Number("32")) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(Between { expr: Identifier([Ident("age")]), negated: false, low: Value(Number("25")), high: Value(Number("32")) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM customers WHERE age NOT BETWEEN 25 AND 32 ---- SELECT * FROM customers WHERE age NOT BETWEEN 25 AND 32 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(Between { expr: Identifier([Ident("age")]), negated: true, low: Value(Number("25")), high: Value(Number("32")) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customers")])), alias: None }, joins: [] }], selection: Some(Between { expr: Identifier([Ident("age")]), negated: true, low: Value(Number("25")), high: Value(Number("32")) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL ---- SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NULL => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(IsExpr { expr: Between { expr: Value(Number("1")), negated: false, low: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) }, high: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("3")), expr2: Some(Value(Number("4"))) } }, construct: Null, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(IsExpr { expr: Between { expr: Value(Number("1")), negated: false, low: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) }, high: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("3")), expr2: Some(Value(Number("4"))) } }, construct: Null, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NOT FALSE AND 3 IS DISTINCT FROM 4 ---- SELECT * FROM t WHERE 1 BETWEEN 1 + 2 AND 3 + 4 IS NOT FALSE AND 3 IS DISTINCT FROM 4 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: IsExpr { expr: Between { expr: Value(Number("1")), negated: false, low: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) }, high: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("3")), expr2: Some(Value(Number("4"))) } }, construct: False, negated: true }, right: IsExpr { expr: Value(Number("3")), construct: DistinctFrom(Value(Number("4"))), negated: false } }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: IsExpr { expr: Between { expr: Value(Number("1")), negated: false, low: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) }, high: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("3")), expr2: Some(Value(Number("4"))) } }, construct: False, negated: true }, right: IsExpr { expr: Value(Number("3")), construct: DistinctFrom(Value(Number("4"))), negated: false } }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement @@ -578,35 +578,35 @@ SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2 ---- SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, right: Between { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Identifier([Ident("x")])) }, negated: false, low: Value(Number("1")), high: Value(Number("2")) } }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, right: Between { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Identifier([Ident("x")])) }, negated: false, low: Value(Number("1")), high: Value(Number("2")) } }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2 ---- SELECT * FROM t WHERE 1 = 1 AND 1 + x BETWEEN 1 AND 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, right: Between { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Identifier([Ident("x")])) }, negated: false, low: Value(Number("1")), high: Value(Number("2")) } }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [] }], selection: Some(And { left: Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }, right: Between { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Identifier([Ident("x")])) }, negated: false, low: Value(Number("1")), high: Value(Number("2")) } }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC, id ---- SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC, id => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("5"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("5"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }) parse-statement SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id ---- SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: None }], limit: None, offset: None }, as_of: None }) parse-statement SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id NULLS FIRST ---- SELECT id, fname, lname FROM customer ORDER BY lname ASC, fname DESC, id NULLS FIRST => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: Some(false) }], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("id")]), asc: None, nulls_last: Some(false) }], limit: None, offset: None }, as_of: None }) parse-statement SELECT id, fname, lname FROM customer WHERE id < 5 @@ -614,35 +614,35 @@ ORDER BY lname ASC, fname DESC NULLS LAST LIMIT 2 ---- SELECT id, fname, lname FROM customer WHERE id < 5 ORDER BY lname ASC, fname DESC NULLS LAST LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("5"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: Some(true) }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "<" }, expr1: Identifier([Ident("id")]), expr2: Some(Value(Number("5"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("lname")]), asc: Some(true), nulls_last: None }, OrderByExpr { expr: Identifier([Ident("fname")]), asc: Some(false), nulls_last: Some(true) }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT id, fname, lname FROM customer GROUP BY lname, fname ---- SELECT id, fname, lname FROM customer GROUP BY lname, fname => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("lname")]), Identifier([Ident("fname")])], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("id")]), alias: None }, Expr { expr: Identifier([Ident("fname")]), alias: None }, Expr { expr: Identifier([Ident("lname")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("lname")]), Identifier([Ident("fname")])], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT foo FROM bar GROUP BY foo HAVING count(*) > 1 ---- SELECT foo FROM bar GROUP BY foo HAVING count(*) > 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: None, over: None, distinct: false }), expr2: Some(Value(Number("1"))) }), options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: None, over: None, distinct: false }), expr2: Some(Value(Number("1"))) }), qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT foo FROM bar GROUP BY foo HAVING count(*) > 1 ---- SELECT foo FROM bar GROUP BY foo HAVING count(*) > 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: None, over: None, distinct: false }), expr2: Some(Value(Number("1"))) }), options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: ">" }, expr1: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Star, filter: None, over: None, distinct: false }), expr2: Some(Value(Number("1"))) }), qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT foo FROM bar GROUP BY foo HAVING 1 = 1 ---- SELECT foo FROM bar GROUP BY foo HAVING 1 = 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }), options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [Identifier([Ident("foo")])], having: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Value(Number("1")), expr2: Some(Value(Number("1"))) }), qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT id, fname, lname FROM customer WHERE id = 1 LIMIT ALL @@ -768,63 +768,63 @@ SELECT * FROM t1, t2 ---- SELECT * FROM t1, t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1a NATURAL JOIN t1b, t2a NATURAL JOIN t2b ---- SELECT * FROM t1a NATURAL JOIN t1b, t2a NATURAL JOIN t2b => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t1b")])), alias: None }, join_operator: Inner(Natural) }] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t2a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2b")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t1b")])), alias: None }, join_operator: Inner(Natural) }] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t2a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2b")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 CROSS JOIN t2 ---- SELECT * FROM t1 CROSS JOIN t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: CrossJoin }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: CrossJoin }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 JOIN t2 AS foo USING (c1) ---- SELECT * FROM t1 JOIN t2 AS foo USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: Some(TableAlias { name: Ident("foo"), columns: [], strict: false }) }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: Some(TableAlias { name: Ident("foo"), columns: [], strict: false }) }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 JOIN t2 foo USING (c1) ---- SELECT * FROM t1 JOIN t2 AS foo USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: Some(TableAlias { name: Ident("foo"), columns: [], strict: false }) }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: Some(TableAlias { name: Ident("foo"), columns: [], strict: false }) }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 NATURAL JOIN t2 ---- SELECT * FROM t1 NATURAL JOIN t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 NATURAL LEFT JOIN t2 ---- SELECT * FROM t1 NATURAL LEFT JOIN t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 NATURAL RIGHT JOIN t2 ---- SELECT * FROM t1 NATURAL RIGHT JOIN t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 NATURAL FULL JOIN t2 ---- SELECT * FROM t1 NATURAL FULL JOIN t2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 natural @@ -838,42 +838,42 @@ SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING (q, c) WHERE ---- SELECT c1, c2 FROM t1, t4 JOIN t2 ON t2.c = t1.c LEFT JOIN t3 USING (q, c) WHERE t4.c = t1.c => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }, Expr { expr: Identifier([Ident("c2")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t4")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("t2"), Ident("c")]), expr2: Some(Identifier([Ident("t1"), Ident("c")])) })) }, Join { relation: Table { name: Name(UnresolvedItemName([Ident("t3")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("q"), Ident("c")], alias: None }) }] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("t4"), Ident("c")]), expr2: Some(Identifier([Ident("t1"), Ident("c")])) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }, Expr { expr: Identifier([Ident("c2")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t4")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("t2"), Ident("c")]), expr2: Some(Identifier([Ident("t1"), Ident("c")])) })) }, Join { relation: Table { name: Name(UnresolvedItemName([Ident("t3")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("q"), Ident("c")], alias: None }) }] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("t4"), Ident("c")]), expr2: Some(Identifier([Ident("t1"), Ident("c")])) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM a NATURAL JOIN (b NATURAL JOIN (c NATURAL JOIN d NATURAL JOIN e)) NATURAL JOIN (f NATURAL JOIN (g NATURAL JOIN h)) ---- SELECT * FROM a NATURAL JOIN (b NATURAL JOIN (c NATURAL JOIN d NATURAL JOIN e)) NATURAL JOIN (f NATURAL JOIN (g NATURAL JOIN h)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("d")])), alias: None }, join_operator: Inner(Natural) }, Join { relation: Table { name: Name(UnresolvedItemName([Ident("e")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }, Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("f")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("g")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("h")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("d")])), alias: None }, join_operator: Inner(Natural) }, Join { relation: Table { name: Name(UnresolvedItemName([Ident("e")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }, Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("f")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("g")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("h")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }, alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM (a NATURAL JOIN b) NATURAL JOIN c ---- SELECT * FROM (a NATURAL JOIN b) NATURAL JOIN c => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM (a NATURAL JOIN b) c NATURAL JOIN d ---- SELECT * FROM (a NATURAL JOIN b) AS c NATURAL JOIN d => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: Some(TableAlias { name: Ident("c"), columns: [], strict: false }) }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("d")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: Some(TableAlias { name: Ident("c"), columns: [], strict: false }) }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("d")])), alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM (((a NATURAL JOIN b))) ---- SELECT * FROM (((a NATURAL JOIN b))) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [] }, alias: None }, joins: [] }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [] }, alias: None }, joins: [] }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM a NATURAL JOIN (((b NATURAL JOIN c))) ---- SELECT * FROM a NATURAL JOIN (((b NATURAL JOIN c))) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [] }, alias: None }, joins: [] }, alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [Join { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: NestedJoin { join: TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("c")])), alias: None }, join_operator: Inner(Natural) }] }, alias: None }, joins: [] }, alias: None }, joins: [] }, alias: None }, join_operator: Inner(Natural) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM (a NATURAL JOIN (b)) @@ -887,14 +887,14 @@ SELECT c1 FROM t1 INNER JOIN t2 USING (c1) ---- SELECT c1 FROM t1 JOIN t2 USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT x.c1 FROM t1 INNER JOIN t2 USING (c1) AS x ---- SELECT x.c1 FROM t1 JOIN t2 USING (c1) AS x => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: Inner(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement @@ -902,42 +902,42 @@ SELECT c1 FROM t1 LEFT OUTER JOIN t2 USING (c1) ---- SELECT c1 FROM t1 LEFT JOIN t2 USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT x.c1 FROM t1 LEFT OUTER JOIN t2 USING (c1) AS x ---- SELECT x.c1 FROM t1 LEFT JOIN t2 USING (c1) AS x => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: LeftOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT c1 FROM t1 RIGHT OUTER JOIN t2 USING (c1) ---- SELECT c1 FROM t1 RIGHT JOIN t2 USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT x.c1 FROM t1 RIGHT OUTER JOIN t2 USING (c1) AS x ---- SELECT x.c1 FROM t1 RIGHT JOIN t2 USING (c1) AS x => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: RightOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT c1 FROM t1 FULL OUTER JOIN t2 USING (c1) ---- SELECT c1 FROM t1 FULL JOIN t2 USING (c1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Using { columns: [Ident("c1")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT x.c1 FROM t1 FULL OUTER JOIN t2 USING (c1) AS x ---- SELECT x.c1 FROM t1 FULL JOIN t2 USING (c1) AS x => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("x"), Ident("c1")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t1")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t2")])), alias: None }, join_operator: FullOuter(Using { columns: [Ident("c1")], alias: Some(Ident("x")) }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t1 JOIN t2 USING (c1) AS @@ -961,7 +961,7 @@ SELECT foo + bar FROM a, b ---- WITH a AS (SELECT 1 AS foo), b AS (SELECT 2 AS bar) SELECT foo + bar FROM a, b => -Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: Some(Ident("foo")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }, Cte { alias: TableAlias { name: Ident("b"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: Some(Ident("bar")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("foo")]), expr2: Some(Identifier([Ident("bar")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: Some(Ident("foo")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }, Cte { alias: TableAlias { name: Ident("b"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: Some(Ident("bar")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("foo")]), expr2: Some(Identifier([Ident("bar")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement CREATE VIEW v AS @@ -972,7 +972,7 @@ CREATE VIEW v AS ---- CREATE VIEW v AS WITH a AS (SELECT 1 AS foo), b AS (SELECT 2 AS bar) SELECT foo + bar FROM a, b => -CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: Some(Ident("foo")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }, Cte { alias: TableAlias { name: Ident("b"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: Some(Ident("bar")) }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("foo")]), expr2: Some(Identifier([Ident("bar")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } } }) +CreateView(CreateViewStatement { if_exists: Error, temporary: false, definition: ViewDefinition { name: UnresolvedItemName([Ident("v")]), columns: [], query: Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("a"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: Some(Ident("foo")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }, Cte { alias: TableAlias { name: Ident("b"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("2")), alias: Some(Ident("bar")) }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("foo")]), expr2: Some(Identifier([Ident("bar")])) }, alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("a")])), alias: None }, joins: [] }, TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("b")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } } }) parse-statement roundtrip WITH cte (col1, col2) AS (SELECT foo, bar FROM baz) SELECT * FROM cte @@ -1051,42 +1051,42 @@ SELECT foo FROM bar OFFSET 2 ROWS ---- SELECT foo FROM bar OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 OFFSET 2 ROWS ---- SELECT foo FROM bar WHERE foo = 4 OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar ORDER BY baz OFFSET 2 ROWS ---- SELECT foo FROM bar ORDER BY baz OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS ---- SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS) OFFSET 2 ROWS ---- SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM LATERAL bar(1) ---- SELECT foo FROM bar(1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("bar")])), args: Args { args: [Value(Number("1"))], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("bar")])), args: Args { args: [Value(Number("1"))], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT foo FROM LATERAL bar @@ -1100,63 +1100,63 @@ SELECT 'foo' OFFSET 0 ROWS ---- SELECT 'foo' OFFSET 0 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("0"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("0"))) }, as_of: None }) parse-statement SELECT foo FROM bar OFFSET 2 ---- SELECT foo FROM bar OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 OFFSET 2 ---- SELECT foo FROM bar WHERE foo = 4 OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar ORDER BY baz OFFSET 2 ---- SELECT foo FROM bar ORDER BY baz OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ---- SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 ---- SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS) OFFSET 2 ---- SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 ROWS ---- SELECT foo FROM (SELECT * FROM bar OFFSET 2) OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT 'foo' OFFSET 0 ---- SELECT 'foo' OFFSET 0 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("0"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: Some(Value(Number("0"))) }, as_of: None }) parse-statement roundtrip SELECT foo FROM bar OFFSET 1 ROW @@ -1168,42 +1168,42 @@ SELECT foo FROM bar FETCH FIRST 2 ROWS ONLY ---- SELECT foo FROM bar LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT 'foo' FETCH FIRST 2 ROWS ONLY ---- SELECT 'foo' LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(String("foo")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH FIRST ROWS ONLY ---- SELECT foo FROM bar LIMIT 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 FETCH FIRST 2 ROWS ONLY ---- SELECT foo FROM bar WHERE foo = 4 LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar ORDER BY baz FETCH FIRST 2 ROWS ONLY ---- SELECT foo FROM bar ORDER BY baz LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar WHERE foo = 4 ORDER BY baz FETCH FIRST 2 ROWS WITH TIES ---- SELECT foo FROM bar WHERE foo = 4 ORDER BY baz FETCH FIRST 2 ROWS WITH TIES => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: true, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: true, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH FIRST 50 PERCENT ROWS ONLY @@ -1217,98 +1217,98 @@ SELECT foo FROM bar WHERE foo = 4 ORDER BY baz OFFSET 2 ROWS FETCH FIRST 2 ROWS ---- SELECT foo FROM bar WHERE foo = 4 ORDER BY baz LIMIT 2 OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("foo")]), expr2: Some(Value(Number("4"))) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [OrderByExpr { expr: Identifier([Ident("baz")]), asc: None, nulls_last: None }], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar FETCH FIRST 2 ROWS ONLY) FETCH FIRST 2 ROWS ONLY ---- SELECT foo FROM (SELECT * FROM bar LIMIT 2) LIMIT 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM (SELECT * FROM bar OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY) OFFSET 2 ROWS FETCH FIRST 2 ROWS ONLY ---- SELECT foo FROM (SELECT * FROM bar LIMIT 2 OFFSET 2) LIMIT 2 OFFSET 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("2")) }), offset: Some(Value(Number("2"))) }, as_of: None }) parse-statement SELECT foo FROM bar FETCH FIRST 10 ROW ONLY ---- SELECT foo FROM bar LIMIT 10 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("10")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("10")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH NEXT 10 ROW ONLY ---- SELECT foo FROM bar LIMIT 10 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("10")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("10")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH NEXT 10 ROWS WITH TIES ---- SELECT foo FROM bar FETCH FIRST 10 ROWS WITH TIES => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: true, quantity: Value(Number("10")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: true, quantity: Value(Number("10")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH NEXT ROWS WITH TIES ---- SELECT foo FROM bar FETCH FIRST 1 ROWS WITH TIES => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: true, quantity: Value(Number("1")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: true, quantity: Value(Number("1")) }), offset: None }, as_of: None }) parse-statement SELECT foo FROM bar FETCH FIRST ROWS ONLY ---- SELECT foo FROM bar LIMIT 1 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("foo")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("bar")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("1")) }), offset: None }, as_of: None }) parse-statement SELECT * FROM customer LEFT JOIN (SELECT * FROM "order" WHERE "order".customer = customer.id LIMIT 3) AS "order" ON true ---- SELECT * FROM customer LEFT JOIN (SELECT * FROM "order" WHERE "order".customer = customer.id LIMIT 3) AS "order" ON true => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("order")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("order"), Ident("customer")]), expr2: Some(Identifier([Ident("customer"), Ident("id")])) }), group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("3")) }), offset: None }, alias: Some(TableAlias { name: Ident("order"), columns: [], strict: false }) }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("order")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("order"), Ident("customer")]), expr2: Some(Identifier([Ident("customer"), Ident("id")])) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("3")) }), offset: None }, alias: Some(TableAlias { name: Ident("order"), columns: [], strict: false }) }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM customer LEFT JOIN LATERAL (SELECT * FROM "order" WHERE "order".customer = customer.id LIMIT 3) AS "order" ON true ---- SELECT * FROM customer LEFT JOIN LATERAL (SELECT * FROM "order" WHERE "order".customer = customer.id LIMIT 3) AS "order" ON true => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Derived { lateral: true, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("order")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("order"), Ident("customer")]), expr2: Some(Identifier([Ident("customer"), Ident("id")])) }), group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("3")) }), offset: None }, alias: Some(TableAlias { name: Ident("order"), columns: [], strict: false }) }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Derived { lateral: true, subquery: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("order")])), alias: None }, joins: [] }], selection: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("order"), Ident("customer")]), expr2: Some(Identifier([Ident("customer"), Ident("id")])) }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("3")) }), offset: None }, alias: Some(TableAlias { name: Ident("order"), columns: [], strict: false }) }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM customer LEFT JOIN LATERAL generate_series(1, customer.id) ON true ---- SELECT * FROM customer LEFT JOIN generate_series(1, customer.id) ON true => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Identifier([Ident("customer"), Ident("id")])], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Identifier([Ident("customer"), Ident("id")])], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, join_operator: LeftOuter(On(Value(Boolean(true)))) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM LATERAL ROWS FROM (generate_series(1, 2), generate_series(3, 5)) ---- SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM LATERAL ROWS FROM (generate_series(1, 2), generate_series(3, 5)) AS alias ---- SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) AS alias => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: Some(TableAlias { name: Ident("alias"), columns: [], strict: false }), with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: Some(TableAlias { name: Ident("alias"), columns: [], strict: false }), with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM generate_series(1, 2) WITH ORDINALITY ---- SELECT * FROM generate_series(1, 2) WITH ORDINALITY => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: true }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: true }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM ROWS FROM (generate_series(1, 2) WITH ORDINALITY) @@ -1322,14 +1322,14 @@ SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) WITH ORDI ---- SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) WITH ORDINALITY => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: true }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: true }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) ---- SELECT * FROM ROWS FROM (generate_series(1, 2), generate_series(3, 5)) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: RowsFrom { functions: [Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("1")), Value(Number("2"))], order_by: [] }, filter: None, over: None, distinct: false }, Function { name: Name(UnresolvedItemName([Ident("generate_series")])), args: Args { args: [Value(Number("3")), Value(Number("5"))], order_by: [] }, filter: None, over: None, distinct: false }], alias: None, with_ordinality: false }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Ensure parsing AS OF is case-insensitive parse-statement @@ -1337,14 +1337,14 @@ SELECT * FROM data as of now() ---- SELECT * FROM data AS OF now() => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Function(Function { name: Name(UnresolvedItemName([Ident("now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Function(Function { name: Name(UnresolvedItemName([Ident("now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }))) }) parse-statement SELECT * FROM data AS OF now() ---- SELECT * FROM data AS OF now() => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Function(Function { name: Name(UnresolvedItemName([Ident("now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Function(Function { name: Name(UnresolvedItemName([Ident("now")])), args: Args { args: [], order_by: [] }, filter: None, over: None, distinct: false }))) }) parse-statement @@ -1352,7 +1352,7 @@ SELECT * FROM data AS OF AT LEAST 5 ---- SELECT * FROM data AS OF AT LEAST 5 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(AtLeast(Value(Number("5")))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("data")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(AtLeast(Value(Number("5")))) }) # Query hints parse-statement @@ -1396,28 +1396,28 @@ SELECT LIST[1, 2, 3] ---- SELECT LIST[1, 2, 3] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: List([Value(Number("1")), Value(Number("2")), Value(Number("3"))]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: List([Value(Number("1")), Value(Number("2")), Value(Number("3"))]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT LIST(SELECT 1) ---- SELECT LIST(SELECT 1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT LIST(SELECT 2 * 10) ---- SELECT LIST(SELECT 2 * 10) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT LIST(SELECT customer.id FROM customer JOIN user on customer.id = user.id LIMIT 12) ---- SELECT LIST(SELECT customer.id FROM customer JOIN user ON customer.id = user.id LIMIT 12) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("customer"), Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("customer"), Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT LIST( @@ -1433,7 +1433,7 @@ SELECT LIST( ---- SELECT LIST(WITH usps AS (SELECT 42) SELECT LIST[customer.id, LIST[customer.first_name, customer.last_name], LIST[LIST[customer.zip]]] FROM customer JOIN user ON customer.id = user.id LIMIT 12) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: List([Identifier([Ident("customer"), Ident("id")]), List([Identifier([Ident("customer"), Ident("first_name")]), Identifier([Ident("customer"), Ident("last_name")])]), List([List([Identifier([Ident("customer"), Ident("zip")])])])]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: List([Identifier([Ident("customer"), Ident("id")]), List([Identifier([Ident("customer"), Ident("first_name")]), Identifier([Ident("customer"), Ident("last_name")])]), List([List([Identifier([Ident("customer"), Ident("zip")])])])]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT LIST( @@ -1443,7 +1443,7 @@ SELECT LIST( ---- SELECT LIST(WITH usps AS (SELECT 42) SELECT * FROM usps) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("usps")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ListSubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("usps")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Map subqueries parse-statement @@ -1451,7 +1451,7 @@ SELECT MAP[1 => a, b => 1 + 2, a || 'b' => (SELECT 1), c => LIST[4, 5]] ---- SELECT MAP[1 => a, b => 1 + 2, a || 'b' => (SELECT 1), c => LIST[4, 5]] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([MapEntry { key: Value(Number("1")), value: Identifier([Ident("a")]) }, MapEntry { key: Identifier([Ident("b")]), value: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) } }, MapEntry { key: Op { op: Op { namespace: None, op: "||" }, expr1: Identifier([Ident("a")]), expr2: Some(Value(String("b"))) }, value: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }) }, MapEntry { key: Identifier([Ident("c")]), value: List([Value(Number("4")), Value(Number("5"))]) }]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([MapEntry { key: Value(Number("1")), value: Identifier([Ident("a")]) }, MapEntry { key: Identifier([Ident("b")]), value: Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("1")), expr2: Some(Value(Number("2"))) } }, MapEntry { key: Op { op: Op { namespace: None, op: "||" }, expr1: Identifier([Ident("a")]), expr2: Some(Value(String("b"))) }, value: Subquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }) }, MapEntry { key: Identifier([Ident("c")]), value: List([Value(Number("4")), Value(Number("5"))]) }]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Map subqueries parse-statement @@ -1459,14 +1459,14 @@ SELECT MAP[] ---- SELECT MAP[] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT MAP['a' => MAP['b' => MAP['c' => 'd', 'e' => 'f'], 'g' => h], 'i' => MAP['j' => 'k']] ---- SELECT MAP['a' => MAP['b' => MAP['c' => 'd', 'e' => 'f'], 'g' => h], 'i' => MAP['j' => 'k']] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([MapEntry { key: Value(String("a")), value: Map([MapEntry { key: Value(String("b")), value: Map([MapEntry { key: Value(String("c")), value: Value(String("d")) }, MapEntry { key: Value(String("e")), value: Value(String("f")) }]) }, MapEntry { key: Value(String("g")), value: Identifier([Ident("h")]) }]) }, MapEntry { key: Value(String("i")), value: Map([MapEntry { key: Value(String("j")), value: Value(String("k")) }]) }]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Map([MapEntry { key: Value(String("a")), value: Map([MapEntry { key: Value(String("b")), value: Map([MapEntry { key: Value(String("c")), value: Value(String("d")) }, MapEntry { key: Value(String("e")), value: Value(String("f")) }]) }, MapEntry { key: Value(String("g")), value: Identifier([Ident("h")]) }]) }, MapEntry { key: Value(String("i")), value: Map([MapEntry { key: Value(String("j")), value: Value(String("k")) }]) }]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT MAP[1, 2] @@ -1487,7 +1487,7 @@ SELECT MAP(SELECT 2 * 10) ---- SELECT MAP(SELECT 2 * 10) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: MapSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: MapSubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Array subqueries parse-statement @@ -1495,28 +1495,28 @@ SELECT ARRAY[1, 2, 3] ---- SELECT ARRAY[1, 2, 3] => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Array([Value(Number("1")), Value(Number("2")), Value(Number("3"))]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Array([Value(Number("1")), Value(Number("2")), Value(Number("3"))]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ARRAY(SELECT 1) ---- SELECT ARRAY(SELECT 1) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("1")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ARRAY(SELECT 2 * 10) ---- SELECT ARRAY(SELECT 2 * 10) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "*" }, expr1: Value(Number("2")), expr2: Some(Value(Number("10"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ARRAY(SELECT customer.id FROM customer JOIN user on customer.id = user.id LIMIT 12) ---- SELECT ARRAY(SELECT customer.id FROM customer JOIN user ON customer.id = user.id LIMIT 12) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("customer"), Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("customer"), Ident("id")]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ARRAY( @@ -1532,7 +1532,7 @@ SELECT ARRAY( ---- SELECT ARRAY(WITH usps AS (SELECT 42) SELECT ARRAY[customer.id, ARRAY[customer.first_name, customer.last_name], ARRAY[ARRAY[customer.zip]]] FROM customer JOIN user ON customer.id = user.id LIMIT 12) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Array([Identifier([Ident("customer"), Ident("id")]), Array([Identifier([Ident("customer"), Ident("first_name")]), Identifier([Ident("customer"), Ident("last_name")])]), Array([Array([Identifier([Ident("customer"), Ident("zip")])])])]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Expr { expr: Array([Identifier([Ident("customer"), Ident("id")]), Array([Identifier([Ident("customer"), Ident("first_name")]), Identifier([Ident("customer"), Ident("last_name")])]), Array([Array([Identifier([Ident("customer"), Ident("zip")])])])]), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("customer")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("user")])), alias: None }, join_operator: Inner(On(Op { op: Op { namespace: None, op: "=" }, expr1: Identifier([Ident("customer"), Ident("id")]), expr2: Some(Identifier([Ident("user"), Ident("id")])) })) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: Some(Limit { with_ties: false, quantity: Value(Number("12")) }), offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT ARRAY( @@ -1542,7 +1542,7 @@ SELECT ARRAY( ---- SELECT ARRAY(WITH usps AS (SELECT 42) SELECT * FROM usps) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("usps")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: ArraySubquery(Query { ctes: Simple([Cte { alias: TableAlias { name: Ident("usps"), columns: [], strict: false }, id: (), query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Value(Number("42")), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None } }]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("usps")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement roundtrip SELECT count(DISTINCT *) FROM foo @@ -1556,14 +1556,14 @@ SELECT * FROM (SHOW TABLES) ---- SELECT * FROM (SHOW TABLES) => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Show(ShowObjects(ShowObjectsStatement { object_type: Table { on_source: None }, from: None, filter: None })), order_by: [], limit: None, offset: None }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Derived { lateral: false, subquery: Query { ctes: Simple([]), body: Show(ShowObjects(ShowObjectsStatement { object_type: Table { on_source: None }, from: None, filter: None })), order_by: [], limit: None, offset: None }, alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT NULLIF(x, '') ---- SELECT NULLIF(x, '') => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: NullIf { l_expr: Identifier([Ident("x")]), r_expr: Value(String("")) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: NullIf { l_expr: Identifier([Ident("x")]), r_expr: Value(String("")) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # parse a plausibly correct WITH MUTUALLY RECURSIVE query. parse-statement roundtrip @@ -1612,7 +1612,7 @@ SELECT * FROM table_function(x) WHERE x IS NULL ---- SELECT * FROM table_function(x) WHERE x IS NULL => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("table_function")])), args: Args { args: [Identifier([Ident("x")])], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, joins: [] }], selection: Some(IsExpr { expr: Identifier([Ident("x")]), construct: Null, negated: false }), group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Function { function: Function { name: Name(UnresolvedItemName([Ident("table_function")])), args: Args { args: [Identifier([Ident("x")])], order_by: [] }, filter: None, over: None, distinct: false }, alias: None, with_ordinality: false }, joins: [] }], selection: Some(IsExpr { expr: Identifier([Ident("x")]), construct: Null, negated: false }), group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) # Table functions do not support OVER clauses parse-statement @@ -1734,7 +1734,7 @@ SELECT * FROM valid AS OF 2 ---- SELECT * FROM valid AS OF 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("valid")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("2")))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("valid")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("2")))) }) parse-statement SELECT extract('year', d) @@ -1748,28 +1748,28 @@ select 2 OPERATOR(*) 2 + 2 ---- SELECT 2 OPERATOR(*) 2 + 2 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: Some([]), op: "*" }, expr1: Value(Number("2")), expr2: Some(Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Value(Number("2"))) }) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: Some([]), op: "*" }, expr1: Value(Number("2")), expr2: Some(Op { op: Op { namespace: None, op: "+" }, expr1: Value(Number("2")), expr2: Some(Value(Number("2"))) }) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement select count(distinct s) from y ---- SELECT count(DISTINCT s) FROM y => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Args { args: [Identifier([Ident("s")])], order_by: [] }, filter: None, over: None, distinct: true }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("y")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Function(Function { name: Name(UnresolvedItemName([Ident("count")])), args: Args { args: [Identifier([Ident("s")])], order_by: [] }, filter: None, over: None, distinct: true }), alias: None }], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("y")])), alias: None }, joins: [] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT * FROM t JOIN t USING (a) AS OF 1234 ---- SELECT * FROM t JOIN t USING (a) AS OF 1234 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, join_operator: Inner(Using { columns: [Ident("a")], alias: None }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("1234")))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, join_operator: Inner(Using { columns: [Ident("a")], alias: None }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("1234")))) }) parse-statement SELECT * FROM t JOIN t USING (a) AS b AS OF 1234 ---- SELECT * FROM t JOIN t USING (a) AS b AS OF 1234 => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, join_operator: Inner(Using { columns: [Ident("a")], alias: Some(Ident("b")) }) }] }], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("1234")))) }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, join_operator: Inner(Using { columns: [Ident("a")], alias: Some(Ident("b")) }) }] }], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("1234")))) }) parse-statement @@ -1791,11 +1791,18 @@ SELECT interval ---- SELECT interval => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("interval")]), alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Identifier([Ident("interval")]), alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) parse-statement SELECT interval + '1h' ---- SELECT interval + '1h' => -Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("interval")]), expr2: Some(Value(String("1h"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Expr { expr: Op { op: Op { namespace: None, op: "+" }, expr1: Identifier([Ident("interval")]), expr2: Some(Value(String("1h"))) }, alias: None }], from: [], selection: None, group_by: [], having: None, qualify: None, options: [] }), order_by: [], limit: None, offset: None }, as_of: None }) + +parse-statement +SELECT * FROM t JOIN t USING (a) AS b QUALIFY sum(a) OVER () = 1 AS OF 1234 +---- +SELECT * FROM t JOIN t USING (a) AS b QUALIFY sum(a) OVER () = 1 AS OF 1234 +=> +Select(SelectStatement { query: Query { ctes: Simple([]), body: Select(Select { distinct: None, projection: [Wildcard], from: [TableWithJoins { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, joins: [Join { relation: Table { name: Name(UnresolvedItemName([Ident("t")])), alias: None }, join_operator: Inner(Using { columns: [Ident("a")], alias: Some(Ident("b")) }) }] }], selection: None, group_by: [], having: None, qualify: Some(Op { op: Op { namespace: None, op: "=" }, expr1: Function(Function { name: Name(UnresolvedItemName([Ident("sum")])), args: Args { args: [Identifier([Ident("a")])], order_by: [] }, filter: None, over: Some(WindowSpec { partition_by: [], order_by: [], window_frame: None, ignore_nulls: false, respect_nulls: false }), distinct: false }), expr2: Some(Value(Number("1"))) }), options: [] }), order_by: [], limit: None, offset: None }, as_of: Some(At(Value(Number("1234")))) }) diff --git a/src/sql-pretty/src/doc.rs b/src/sql-pretty/src/doc.rs index 0da1c7e36f692..fa32d1934abf3 100644 --- a/src/sql-pretty/src/doc.rs +++ b/src/sql-pretty/src/doc.rs @@ -531,6 +531,9 @@ fn doc_select(v: &Select) -> RcDoc { if let Some(having) = &v.having { docs.push(nest_title("HAVING", doc_expr(having))); } + if let Some(qualify) = &v.qualify { + docs.push(nest_title("QUALIFY", doc_expr(qualify))); + } if !v.options.is_empty() { docs.push(bracket( "OPTIONS (", diff --git a/src/sql/src/plan/query.rs b/src/sql/src/plan/query.rs index 87fe6007f5874..0ebd6fd7f64fb 100644 --- a/src/sql/src/plan/query.rs +++ b/src/sql/src/plan/query.rs @@ -2330,10 +2330,10 @@ fn plan_view_select( relation_expr = relation_expr.filter(vec![expr]); } - // Step 7. Gather window functions from SELECT and ORDER BY, and plan them. + // Step 7. Gather window functions from SELECT, ORDER BY, and QUALIFY, and plan them. // (This includes window aggregations.) // - // Note that window functions can be present only in SELECT and ORDER BY (including + // Note that window functions can be present only in SELECT, ORDER BY, or QUALIFY (including // DISTINCT ON), because they are executed after grouped aggregations and HAVING. // // Also note that window functions in the ORDER BY can't refer to columns introduced in the @@ -2344,6 +2344,9 @@ fn plan_view_select( // expression" let window_funcs = { let mut visitor = WindowFuncCollector::default(); + // The `visit_select` call visits both `SELECT` and `QUALIFY` (and many other things, but + // window functions are excluded from other things by `allow_windows` being false when + // planning those before this code). visitor.visit_select(&s); for o in order_by_exprs.iter() { visitor.visit_order_by_expr(o); @@ -2364,8 +2367,28 @@ fn plan_view_select( relation_expr = relation_expr.map(vec![plan_expr(ecx, &window_func)?.type_as_any(ecx)?]); group_scope.items.push(ScopeItem::from_expr(window_func)); } + // From this point on, we shouldn't encounter _valid_ window function calls, because those have + // been already planned now. However, we should still set `allow_windows: true` for the + // remaining planning of `QUALIFY`, `SELECT`, and `ORDER BY`, in order to have a correct error + // msg if an OVER clause is missing from a window function. - // Step 8. Handle SELECT clause. + // Step 8. Handle QUALIFY clause. (very similar to HAVING) + if let Some(ref qualify) = s.qualify { + let ecx = &ExprContext { + qcx, + name: "QUALIFY clause", + scope: &group_scope, + relation_type: &qcx.relation_type(&relation_expr), + allow_aggregates: true, + allow_subqueries: true, + allow_parameters: true, + allow_windows: true, + }; + let expr = plan_expr(ecx, qualify)?.type_as(ecx, &ScalarType::Bool)?; + relation_expr = relation_expr.filter(vec![expr]); + } + + // Step 9. Handle SELECT clause. let output_columns = { let mut new_exprs = vec![]; let mut new_type = qcx.relation_type(&relation_expr); @@ -2415,7 +2438,7 @@ fn plan_view_select( }; let mut project_key: Vec<_> = output_columns.iter().map(|(i, _name)| *i).collect(); - // Step 9. Handle intrusive ORDER BY and DISTINCT. + // Step 10. Handle intrusive ORDER BY and DISTINCT. let order_by = { let relation_type = qcx.relation_type(&relation_expr); let (mut order_by, mut map_exprs) = plan_order_by_exprs( diff --git a/src/sql/src/plan/scope.rs b/src/sql/src/plan/scope.rs index 20ea329ec409d..54cd00839fc74 100644 --- a/src/sql/src/plan/scope.rs +++ b/src/sql/src/plan/scope.rs @@ -60,7 +60,7 @@ pub struct ScopeItem { /// The name of the column. pub column_name: ColumnName, /// The expressions from which this scope item is derived. Used by `GROUP - /// BY`. + /// BY` and window functions. pub exprs: BTreeSet>, /// Whether the column is the return value of a function that produces only /// a single column. This accounts for a strange PostgreSQL special case diff --git a/src/sql/src/plan/side_effecting_func.rs b/src/sql/src/plan/side_effecting_func.rs index ea460a21cbc83..2435fc8c4ff42 100644 --- a/src/sql/src/plan/side_effecting_func.rs +++ b/src/sql/src/plan/side_effecting_func.rs @@ -148,6 +148,7 @@ fn extract_sef_call( selection: None, group_by, having: None, + qualify: None, options, } = &**body else { diff --git a/src/sql/src/plan/statement/ddl.rs b/src/sql/src/plan/statement/ddl.rs index 2d3f678e9cb4f..a4ad1b7bf9c7f 100644 --- a/src/sql/src/plan/statement/ddl.rs +++ b/src/sql/src/plan/statement/ddl.rs @@ -3111,6 +3111,7 @@ fn continual_task_query<'a>( projection: vec![ast::SelectItem::Wildcard], group_by: Vec::new(), having: None, + qualify: None, options: Vec::new(), }; let query = ast::Query { diff --git a/src/sqllogictest/src/runner.rs b/src/sqllogictest/src/runner.rs index e76873be6a8ec..b9b2229f44728 100644 --- a/src/sqllogictest/src/runner.rs +++ b/src/sqllogictest/src/runner.rs @@ -2405,6 +2405,7 @@ fn generate_view_sql( selection: None, group_by: vec![], having: None, + qualify: None, options: vec![], })), order_by: view_order_by, diff --git a/test/sqllogictest/sqlite b/test/sqllogictest/sqlite index 262d86a2a2073..11e43fd53e51c 160000 --- a/test/sqllogictest/sqlite +++ b/test/sqllogictest/sqlite @@ -1 +1 @@ -Subproject commit 262d86a2a2073c7a707beaa34be283d3b0ead301 +Subproject commit 11e43fd53e51c95fe26310157f737e8e0e8e57d1 diff --git a/test/sqllogictest/window_funcs.slt b/test/sqllogictest/window_funcs.slt index 093ee7cf9db31..1c6830254b4f5 100644 --- a/test/sqllogictest/window_funcs.slt +++ b/test/sqllogictest/window_funcs.slt @@ -19,7 +19,18 @@ statement ok INSERT INTO t VALUES ('a'), ('b'), ('c'); statement error db error: ERROR: window function pg_catalog\.row_number requires an OVER clause -SELECT row_number() FROM t; +SELECT row_number() +FROM t; + +statement error db error: ERROR: window function pg_catalog\.row_number requires an OVER clause +SELECT * +FROM t +ORDER BY row_number(); + +statement error db error: ERROR: window function pg_catalog\.row_number requires an OVER clause +SELECT * +FROM t +QUALIFY row_number(); statement error db error: ERROR: OVER clause not allowed on pg_catalog\.int8range\. The OVER clause can only be used with window functions \(including aggregations\)\. SELECT int8range(1, 1, '') OVER (PARTITION BY 1 ORDER BY 1); @@ -7904,3 +7915,97 @@ FROM ( ); ---- 69999 + +## QUALIFY +query II +SELECT * +FROM t6 +QUALIFY row_number() OVER (PARTITION BY x%3 ORDER BY y) = 1; +---- +1 2 +5 6 +15 16 + +query IIII +SELECT *, x%3, row_number() OVER (PARTITION BY x%3 ORDER BY y) +FROM t6 +QUALIFY row_number() OVER (PARTITION BY x%3 ORDER BY y) = 1; +---- +15 16 0 1 +1 2 1 1 +5 6 2 1 + +query II +SELECT * +FROM t6 +QUALIFY sum(x) OVER (ORDER BY y) = 26; +---- +13 14 + +query II +SELECT * +FROM (SELECT * FROM t6 UNION ALL SELECT * FROM t6) +QUALIFY sum(x) OVER (ORDER BY y) = 26; +---- +7 8 +7 8 + +query I +SELECT avg(u) +FROM ( + SELECT x, unnest(l) AS u + FROM ( + SELECT x, array_agg(y) OVER (PARTITION BY x%5) AS l + FROM t7 + ) AS ff1 +) AS ff2 +GROUP BY x%5 +QUALIFY sum(avg(u)) OVER (ORDER BY x%5) = -15 +ORDER BY x%5; +---- +2 + +query II +SELECT * +FROM ( + SELECT x, unnest(l) AS u + FROM ( + SELECT x, array_agg(y) OVER (PARTITION BY x%5) AS l + FROM t7 + ) AS ff1 +) +QUALIFY x-lag(x) OVER (ORDER BY x) = 0 AND lag(x) OVER (ORDER BY x) - lag(lag(x) OVER (ORDER BY x)) OVER (ORDER BY x) = 0 +ORDER BY x,u; +---- +5 6 +5 16 +10 -40 +10 -40 +10 6 +10 6 +10 16 +10 16 +15 6 +15 16 + +query III +SELECT *, sum(x-9) OVER (ORDER BY x, u) +FROM +( + SELECT DISTINCT * + FROM ( + SELECT x, unnest(l) AS u + FROM ( + SELECT x, array_agg(y) OVER (PARTITION BY x%5) AS l + FROM t7 + ) AS ff1 + ) + QUALIFY x-lag(x) OVER (ORDER BY x) = 0 AND lag(x) OVER (ORDER BY x) - lag(lag(x) OVER (ORDER BY x)) OVER (ORDER BY x) = 0 +) +QUALIFY sum(x-9) OVER (ORDER BY x, u) > -6 +ORDER BY x,u; +---- +5 6 -4 +10 16 -5 +15 6 1 +15 16 7