feat(spansql): support subquery in View Join #13266
There are no files selected for viewing
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -365,6 +365,65 @@ func TestParseQuery(t *testing.T) { | |
| }, | ||
| }, | ||
| }, | ||
| // Scalar subqueries in SELECT list - ensures parseLit handles (SELECT ...) correctly | ||
| { | ||
| `SELECT (SELECT MAX(id) FROM t1), name FROM t2`, | ||
| Query{ | ||
| Select: Select{ | ||
| List: []Expr{ | ||
| ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{Func{Name: "MAX", Args: []Expr{ID("id")}}}, | ||
| From: []SelectFrom{SelectFromTable{Table: "t1"}}, | ||
| }, | ||
| }, | ||
| }, | ||
| ID("name"), | ||
| }, | ||
| From: []SelectFrom{SelectFromTable{Table: "t2"}}, | ||
| }, | ||
| }, | ||
| }, | ||
| // Scalar subquery in WHERE clause | ||
| { | ||
| `SELECT * FROM users WHERE age > (SELECT AVG(age) FROM users)`, | ||
| Query{ | ||
| Select: Select{ | ||
| List: []Expr{Star}, | ||
| From: []SelectFrom{SelectFromTable{Table: "users"}}, | ||
| Where: ComparisonOp{ | ||
| Op: Gt, | ||
| LHS: ID("age"), | ||
| RHS: ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{Func{Name: "AVG", Args: []Expr{ID("age")}}}, | ||
| From: []SelectFrom{SelectFromTable{Table: "users"}}, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| // Parenthesized expression in SELECT list - ensures parseLit handles (expr) correctly | ||
| { | ||
| `SELECT (1 + 2) * 3, name FROM t`, | ||
| Query{ | ||
| Select: Select{ | ||
| List: []Expr{ | ||
| ArithOp{ | ||
| LHS: Paren{Expr: ArithOp{LHS: IntegerLiteral(1), Op: Add, RHS: IntegerLiteral(2)}}, | ||
| Op: Mul, | ||
| RHS: IntegerLiteral(3), | ||
| }, | ||
| ID("name"), | ||
| }, | ||
| From: []SelectFrom{SelectFromTable{Table: "t"}}, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| for _, test := range tests { | ||
| got, err := ParseQuery(test.in) | ||
|
|
@@ -634,6 +693,53 @@ func TestParseExpr(t *testing.T) { | |
| // Reserved keywords. | ||
| {`TRUE AND FALSE`, LogicalOp{LHS: True, Op: And, RHS: False}}, | ||
| {`NULL`, Null}, | ||
|
|
||
| // Parenthesized expressions - test that parseLit correctly handles the opening paren. | ||
| // The opening "(" is consumed by p.next(), then parseExpr is called for the contents. | ||
| {`(1)`, Paren{Expr: IntegerLiteral(1)}}, | ||
| {`(1 + 2)`, Paren{Expr: ArithOp{LHS: IntegerLiteral(1), Op: Add, RHS: IntegerLiteral(2)}}}, | ||
| {`((1 + 2))`, Paren{Expr: Paren{Expr: ArithOp{LHS: IntegerLiteral(1), Op: Add, RHS: IntegerLiteral(2)}}}}, | ||
| {`(1 + 2) * 3`, ArithOp{LHS: Paren{Expr: ArithOp{LHS: IntegerLiteral(1), Op: Add, RHS: IntegerLiteral(2)}}, Op: Mul, RHS: IntegerLiteral(3)}}, | ||
| {`((1 + 2) * 3)`, Paren{Expr: ArithOp{LHS: Paren{Expr: ArithOp{LHS: IntegerLiteral(1), Op: Add, RHS: IntegerLiteral(2)}}, Op: Mul, RHS: IntegerLiteral(3)}}}, | ||
| {`(A AND B) OR C`, LogicalOp{LHS: Paren{Expr: LogicalOp{LHS: ID("A"), Op: And, RHS: ID("B")}}, Op: Or, RHS: ID("C")}}, | ||
| {`(TRUE)`, Paren{Expr: True}}, | ||
| {`(NULL)`, Paren{Expr: Null}}, | ||
|
|
||
| // Scalar subqueries - test that parseLit correctly distinguishes (SELECT ...) from (expr). | ||
| // When p.sniff("SELECT") is true after consuming "(", parseQuery is called instead of parseExpr. | ||
| { | ||
| `(SELECT 1)`, | ||
| ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{IntegerLiteral(1)}, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| { | ||
| `(SELECT MAX(x) FROM t)`, | ||
| ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{Func{Name: "MAX", Args: []Expr{ID("x")}}}, | ||
| From: []SelectFrom{SelectFromTable{Table: "t"}}, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| { | ||
| `(SELECT COUNT(*) FROM users WHERE active = TRUE)`, | ||
| ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{Func{Name: "COUNT", Args: []Expr{Star}}}, | ||
| From: []SelectFrom{SelectFromTable{Table: "users"}}, | ||
| Where: ComparisonOp{LHS: ID("active"), Op: Eq, RHS: True}, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| for _, test := range tests { | ||
| p := newParser("test-file", test.in) | ||
|
|
@@ -2415,6 +2521,95 @@ func TestParseDDL(t *testing.T) { | |
| }, | ||
| }, | ||
| }, | ||
| { | ||
| `CREATE OR REPLACE VIEW Transaction SQL SECURITY INVOKER AS SELECT | ||
| ID, Name, Amount, AccountID, PaymentID | ||
| FROM | ||
| Transactions as t | ||
| JOIN Accounts as acc ON t.AccountID = acc.ID | ||
| JOIN Payment as p ON t.PaymentID = p.ID | ||
| AND p.EventSequence = ( | ||
| SELECT MAX(p2.EventSequence) | ||
| FROM Payment as p2 | ||
| WHERE p2.ID = p.ID | ||
| )`, | ||
| &DDL{ | ||
| Filename: "filename", | ||
| List: []DDLStmt{ | ||
| &CreateView{ | ||
| Name: "Transaction", | ||
| OrReplace: true, | ||
| SecurityType: Invoker, | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{ID("ID"), ID("Name"), ID("Amount"), ID("AccountID"), ID("PaymentID")}, | ||
| From: []SelectFrom{ | ||
| SelectFromJoin{ | ||
| Type: InnerJoin, | ||
| LHS: SelectFromJoin{ | ||
| Type: InnerJoin, | ||
| LHS: SelectFromTable{ | ||
| Table: "Transactions", | ||
| Alias: "t", | ||
| }, | ||
| RHS: SelectFromTable{ | ||
| Table: "Accounts", | ||
| Alias: "acc", | ||
| }, | ||
| On: ComparisonOp{ | ||
| LHS: PathExp{"t", "AccountID"}, | ||
| Op: Eq, | ||
| RHS: PathExp{"acc", "ID"}, | ||
| }, | ||
| }, | ||
| RHS: SelectFromTable{ | ||
| Table: "Payment", | ||
| Alias: "p", | ||
| }, | ||
| On: LogicalOp{ | ||
| LHS: ComparisonOp{ | ||
| LHS: PathExp{"t", "PaymentID"}, | ||
| Op: Eq, | ||
| RHS: PathExp{"p", "ID"}, | ||
| }, | ||
| Op: And, | ||
| RHS: ComparisonOp{ | ||
| LHS: PathExp{"p", "EventSequence"}, | ||
| Op: Eq, | ||
| RHS: ScalarSubquery{ | ||
| Query: Query{ | ||
| Select: Select{ | ||
| List: []Expr{ | ||
| Func{ | ||
| Name: "MAX", | ||
| Args: []Expr{PathExp{"p2", "EventSequence"}}, | ||
| }, | ||
| }, | ||
| From: []SelectFrom{ | ||
| SelectFromTable{ | ||
| Table: "Payment", | ||
| Alias: "p2", | ||
| }, | ||
| }, | ||
| Where: ComparisonOp{ | ||
| LHS: PathExp{"p2", "ID"}, | ||
| Op: Eq, | ||
| RHS: PathExp{"p", "ID"}, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| Position: line(1), | ||
| }, | ||
| }, | ||
| }, | ||
| }, | ||
| } | ||
| for _, test := range tests { | ||
| got, err := ParseDDL("filename", test.in) | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -1084,6 +1084,13 @@ func (eo ExistsOp) addSQL(sb *strings.Builder) { | |
| sb.WriteString(")") | ||
| } | ||
|
|
||
| func (ss ScalarSubquery) SQL() string { return buildSQL(ss) } | ||
| func (ss ScalarSubquery) addSQL(sb *strings.Builder) { | ||
| sb.WriteString("(") | ||
| ss.Query.addSQL(sb) | ||
| sb.WriteString(")") | ||
| } | ||
|
|
||
| func (io InOp) SQL() string { return buildSQL(io) } | ||
| func (io InOp) addSQL(sb *strings.Builder) { | ||
| io.LHS.addSQL(sb) | ||
|
|
||
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -815,6 +815,12 @@ type ExistsOp struct { | |
| func (ExistsOp) isBoolExpr() {} // usually | ||
| func (ExistsOp) isExpr() {} | ||
|
|
||
| type ScalarSubquery struct { | ||
| Query Query | ||
| } | ||
|
|
||
| func (ScalarSubquery) isExpr() {} | ||
|
|
||
| type InOp struct { | ||
| LHS Expr | ||
| Neg bool | ||
|
|
||
Oops, something went wrong.
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
There was a problem hiding this comment.
Choose a reason for hiding this comment
The reason will be displayed to describe this comment to others. Learn more.
when running vet.sh from the workflows folder these changes were applied