From cbc7f45af57929a221b00f50dcad5adea1bc0cd6 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Fri, 13 Sep 2024 16:07:55 -0700 Subject: [PATCH 01/14] [sqlparser] recursive descent parser gen --- go/vt/sqlparser/gen/cmd/main.go | 180 +++ go/vt/sqlparser/gen/testdata/expr_functions | 309 +++++ go/vt/sqlparser/rdparser.go | 66 + go/vt/sqlparser/sql.gen.go | 1346 +++++++++++++++++++ 4 files changed, 1901 insertions(+) create mode 100644 go/vt/sqlparser/gen/cmd/main.go create mode 100644 go/vt/sqlparser/gen/testdata/expr_functions create mode 100644 go/vt/sqlparser/rdparser.go create mode 100644 go/vt/sqlparser/sql.gen.go diff --git a/go/vt/sqlparser/gen/cmd/main.go b/go/vt/sqlparser/gen/cmd/main.go new file mode 100644 index 00000000000..2f06fcb070f --- /dev/null +++ b/go/vt/sqlparser/gen/cmd/main.go @@ -0,0 +1,180 @@ +package main + +import ( + "fmt" + "log" + "os" + "strings" +) + +//go:generate go run ./main.go ../testdata/expr_functions + +func main() { + // split file into definitions + // each definition gets a symbol + // parse each definition into a function + args := os.Args[1:] + //outfile, err := os.CreateTemp("", "") + // //if err != nil { + // // log.Fatal(err) + // //} + outfile, err := os.OpenFile("../../sql.gen.go", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) + if err != nil { + log.Fatal(err) + } + log.Println("writing to: ", outfile.Name()) + + for _, inp := range args { + bytes, err := os.ReadFile(inp) + if err != nil { + log.Fatalf("invalid filename: %s; err=%s", inp, err) + } + p := &pgen{lines: strings.Split(string(bytes), "\n")} + out, err := p.gen() + if err != nil { + log.Fatalf("invalid contents: %s; err=%s", inp, err) + } + n, err := outfile.WriteString(out) + if err != nil || n != len(out) { + log.Fatalf("failed to write results: %s; err=%s", inp, err) + } + } + outfile.Sync() +} + +type pgen struct { + lines []string + i int +} + +func (p *pgen) nextLine() (string, bool) { + if p.i >= len(p.lines) { + return "", false + } + l := p.lines[p.i] + p.i++ + l = strings.TrimSpace(l) + if len(l) > 2 && l[:2] == "| " { + l = l[2:] + } + if len(l) > 2 && l[:2] == "//" { + return p.nextLine() + } + + if len(l) == 0 { + return p.nextLine() + } + return l, true +} + +func (p *pgen) gen() (string, error) { + b := strings.Builder{} + fmt.Fprintf(&b, "package sqlparser\n\n") + + //l, ok := p.nextLine() + //if !ok { + // return "", fmt.Errorf("function id invalid") + //} + //fid := strings.Split(l, ":") + //if len(fid) < 1 { + // return "", fmt.Errorf("function id invalid") + //} + //fmt.Fprintf(&b, "func (p *parser) %s() (Expr, bool) {\n", camelize(fid[0])) + //fmt.Fprintf(&b, " id, tok := p.peek()\n") + topIfElse := " if" + currentFname := "" + for { + def, ok := p.nextLine() + if !ok { + break + } + + if def[len(def)-1] == ':' { + fid := strings.Split(def, ":") + if len(fid) < 1 { + return "", fmt.Errorf("function id invalid") + } + if p.i > 1 { + fmt.Fprintf(&b, "\n return nil, false\n}\n") + } + currentFname = fid[0] + fmt.Fprintf(&b, "func (p *parser) %s() (Expr, bool) {\n", camelize(fid[0])) + fmt.Fprintf(&b, " id, tok := p.peek()\n") + topIfElse = " if" + continue + } + + open, ok := p.nextLine() + if !ok || open != "{" { + return "", fmt.Errorf("missing openb, line %d, %s->%s", p.i, def, open) + } + ret, ok := p.nextLine() + if !ok { + return "", fmt.Errorf("missing return type") + } + close, ok := p.nextLine() + if !ok || close != "}" { + return "", fmt.Errorf("missing closeb") + } + + // progress string for fail message + // differentiate end token vs function + // extend reading tokens into variables + // return + parts := strings.Split(def, " ") + for i, p := range parts { + var cmp string + if p == "openb" { + cmp = "'('" + } else if p == "closeb" { + cmp = "')'" + } else if strings.ToLower(p) == p { + } else { + cmp = p + } + + if i == 0 { + if cmp != "" { + fmt.Fprintf(&b, "%s id == %s {\n", topIfElse, cmp) + fmt.Fprintf(&b, " var1, _ := p.next()\n") + } else { + fname := camelize(p) + fmt.Fprintf(&b, "%s var1, ok := p.%s(); ok {\n", topIfElse, fname) + } + topIfElse = " else if" + continue + } + if cmp != "" { + fmt.Fprintf(&b, " var%d, tok := p.next()\n", i+1) + fmt.Fprintf(&b, " if var%d != %s {\n", i+1, cmp) + fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok) + \"'\")\n", currentFname, strings.Join(parts[:i], " "), cmp) + fmt.Fprintf(&b, " }\n") + } else if strings.ToLower(p) == p { + fname := camelize(p) + fmt.Fprintf(&b, " var%d, ok := p.%s()\n", i+1, fname) + fmt.Fprintf(&b, " if !ok {\n") + fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok)'\")\n", currentFname, strings.Join(parts[:i], " "), p) + fmt.Fprintf(&b, " }\n") + } + } + ret = strings.Replace(ret, "$$ = ", "", -1) + if ret[0] == '&' { + ret = ret[1:] + } + ret = strings.Replace(ret, "$", "var", -1) + fmt.Fprintf(&b, " return &%s, true\n", ret) + fmt.Fprintf(&b, " }") + } + fmt.Fprintf(&b, "\n return nil, false\n}\n") + + return b.String(), nil +} + +func camelize(name string) string { + words := strings.Split(name, "_") + key := strings.ToLower(words[0]) + for _, word := range words[1:] { + key += strings.Title(word) + } + return key +} diff --git a/go/vt/sqlparser/gen/testdata/expr_functions b/go/vt/sqlparser/gen/testdata/expr_functions new file mode 100644 index 00000000000..d334baef756 --- /dev/null +++ b/go/vt/sqlparser/gen/testdata/expr_functions @@ -0,0 +1,309 @@ +function_call_keyword: + LEFT openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| RIGHT openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| FORMAT openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| GROUPING openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| SCHEMA openb closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1))} + } +| CONVERT openb expression ',' convert_type closeb + { + $$ = &ConvertExpr{Name: string($1), Expr: $3, Type: $5} + } +| CAST openb expression AS convert_type closeb + { + $$ = &ConvertExpr{Name: string($1), Expr: $3, Type: $5} + } +| CHAR openb argument_expression_list closeb + { + $$ = &CharExpr{Exprs: $3} + } +| CHAR openb argument_expression_list USING charset closeb + { + $$ = &CharExpr{Exprs: $3, Type: $5} + } +| CONVERT openb expression USING charset closeb + { + $$ = &ConvertUsingExpr{Expr: $3, Type: $5} + } +| POSITION openb value_expression IN value_expression closeb + { + $$ = &FuncExpr{Name: NewColIdent("LOCATE"), Exprs: []SelectExpr{&AliasedExpr{Expr: $3}, &AliasedExpr{Expr: $5}}} + } +| INSERT openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| SUBSTR openb column_name FROM value_expression FOR value_expression closeb + { + $$ = &SubstrExpr{Name: $3, From: $5, To: $7} + } +| SUBSTRING openb column_name FROM value_expression FOR value_expression closeb + { + $$ = &SubstrExpr{Name: $3, From: $5, To: $7} + } +| SUBSTR openb STRING FROM value_expression FOR value_expression closeb + { + $$ = &SubstrExpr{StrVal: NewStrVal($3), From: $5, To: $7} + } +| SUBSTRING openb STRING FROM value_expression FOR value_expression closeb + { + $$ = &SubstrExpr{StrVal: NewStrVal($3), From: $5, To: $7} + } +| TRIM openb value_expression closeb + { + $$ = &TrimExpr{Pattern: NewStrVal([]byte(" ")), Str: $3, Dir: Both} + } +| TRIM openb value_expression FROM value_expression closeb + { + $$ = &TrimExpr{Pattern: $3, Str: $5, Dir: Both} + } +| TRIM openb LEADING value_expression FROM value_expression closeb + { + $$ = &TrimExpr{Pattern: $4, Str: $6, Dir: Leading} + } +| TRIM openb TRAILING value_expression FROM value_expression closeb + { + $$ = &TrimExpr{Pattern: $4, Str: $6, Dir: Trailing} + } +| TRIM openb BOTH value_expression FROM value_expression closeb + { + $$ = &TrimExpr{Pattern: $4, Str: $6, Dir: Both} + } +| MATCH openb argument_expression_list closeb AGAINST openb value_expression match_option closeb + { + $$ = &MatchExpr{Columns: $3, Expr: $7, Option: $8} + } +| FIRST openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| GROUP_CONCAT openb distinct_opt argument_expression_list order_by_opt separator_opt closeb + { + $$ = &GroupConcatExpr{Distinct: $3, Exprs: $4, OrderBy: $5, Separator: $6} + } +| CASE expression_opt when_expression_list else_expression_opt END + { + $$ = &CaseExpr{Expr: $2, Whens: $3, Else: $4} + } +| VALUES openb column_name closeb + { + $$ = &ValuesFuncExpr{Name: $3} + } +| VALUES openb column_name_safe_keyword closeb + { + $$ = &ValuesFuncExpr{Name: NewColName(string($3))} + } +// TODO: non_reserved_keyword and non_reserved_keyword2 cause grammar conflicts +| VALUES openb non_reserved_keyword3 closeb + { + $$ = &ValuesFuncExpr{Name: NewColName(string($3))} + } +| REPEAT openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +function_call_window: + CUME_DIST openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +| DENSE_RANK openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +| FIRST_VALUE openb argument_expression closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: SelectExprs{$3}, Over: $5} + } +| LAG openb argument_expression_list closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| LAST_VALUE openb argument_expression closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: SelectExprs{$3}, Over: $5} + } +| LEAD openb argument_expression_list closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| NTH_VALUE openb argument_expression_list closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| NTILE openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +| PERCENT_RANK openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +| RANK openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +| ROW_NUMBER openb closeb over + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} + } +function_call_aggregate_with_window: + MAX openb distinct_opt argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $4, Distinct: $3 == DistinctStr, Over: $6} + } +| AVG openb distinct_opt argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $4, Distinct: $3 == DistinctStr, Over: $6} + } +| BIT_AND openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| BIT_OR openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| BIT_XOR openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| COUNT openb distinct_opt argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $4, Distinct: $3 == DistinctStr, Over: $6} + } +| JSON_ARRAYAGG openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| JSON_OBJECTAGG openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| MIN openb distinct_opt argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $4, Distinct: $3 == DistinctStr, Over: $6} + } +| STDDEV_POP openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| STDDEV openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| STD openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| STDDEV_SAMP openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| SUM openb distinct_opt argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $4, Distinct: $3 == DistinctStr, Over: $6} + } +| VAR_POP openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| VARIANCE openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +| VAR_SAMP openb argument_expression_list closeb over_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} + } +function_call_conflict: + IF openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| DATABASE openb argument_expression_list_opt closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| MOD openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| REPLACE openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| SUBSTR openb argument_expression_list closeb + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} + } +| SUBSTRING openb argument_expression_list closeb + { + $$ + } +function_call_nonkeyword: +// functions that do not support fractional second precision (fsp) + CURRENT_DATE func_parens_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1))} + } +| CURRENT_USER func_parens_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1))} + } +| UTC_DATE func_parens_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1))} + } +// functions that can be called with optional second argument +| function_call_on_update + { + $$ = $1 + } +| CURRENT_TIME func_datetime_prec_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: SelectExprs{&AliasedExpr{Expr: $2}}} + } +| UTC_TIME func_datetime_prec_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: SelectExprs{&AliasedExpr{Expr: $2}}} + } +| UTC_TIMESTAMP func_datetime_prec_opt + { + $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: SelectExprs{&AliasedExpr{Expr: $2}}} + } +| TIMESTAMPADD openb time_unit ',' value_expression ',' value_expression closeb + { + $$ = &TimestampFuncExpr{Name:string("timestampadd"), Unit:string($3), Expr1:$5, Expr2:$7} + } +| TIMESTAMPDIFF openb time_unit ',' value_expression ',' value_expression closeb + { + $$ = &TimestampFuncExpr{Name:string("timestampdiff"), Unit:string($3), Expr1:$5, Expr2:$7} + } +| EXTRACT openb time_unit FROM value_expression closeb + { + $$ = &ExtractFuncExpr{Name: string($1), Unit: string($3), Expr: $5} + } +function_call_generic: + sql_id openb distinct_opt argument_expression_list_opt closeb + { + $$ = &FuncExpr{Name: $1, Distinct: $3 == DistinctStr, Exprs: $4} + } +| table_id '.' reserved_sql_id openb argument_expression_list_opt closeb + { + $$ = &FuncExpr{Qualifier: $1, Name: $3, Exprs: $5} + } \ No newline at end of file diff --git a/go/vt/sqlparser/rdparser.go b/go/vt/sqlparser/rdparser.go new file mode 100644 index 00000000000..2dc82c1f31e --- /dev/null +++ b/go/vt/sqlparser/rdparser.go @@ -0,0 +1,66 @@ +package sqlparser + +import ( + "context" + "fmt" +) + +type parser struct { + tok *Tokenizer + curOk bool + curId int + cur []byte + peekOk bool + peekId int + _peek []byte +} + +func (p *parser) parse(ctx context.Context, s string, options ParserOptions) (ret Statement, err error) { + defer func() { + if mes := recover(); mes != nil { + _, ok := mes.(parseErr) + if !ok { + err = fmt.Errorf("panic encountered while parsing: %s", mes) + return + } + ret, err = ParseWithOptions(ctx, s, options) + } + }() + // get next token + p.tok = NewStringTokenizer(s) + if options.AnsiQuotes { + p.tok = NewStringTokenizerForAnsiQuotes(s) + } + + if prePlan, ok := p.statement(ctx); ok { + return prePlan, nil + } + + return ParseWithOptions(ctx, s, options) +} + +type parseErr struct { + str string +} + +func (p *parser) fail(s string) { + panic(parseErr{s}) +} + +func (p *parser) next() (int, []byte) { + if p.peekOk { + p.peekOk = false + p.curId, p.cur = p.peekId, p._peek + } + p.curOk = true + p.curId, p.cur = p.tok.Scan() + return p.curId, p.cur +} + +func (p *parser) peek() (int, []byte) { + if !p.peekOk { + p.peekOk = true + p.peekId, p._peek = p.tok.Scan() + } + return p.peekId, p._peek +} diff --git a/go/vt/sqlparser/sql.gen.go b/go/vt/sqlparser/sql.gen.go new file mode 100644 index 00000000000..5b979013454 --- /dev/null +++ b/go/vt/sqlparser/sql.gen.go @@ -0,0 +1,1346 @@ +package sqlparser + +func (p *parser) functionCallKeyword() (Expr, bool) { + id, tok := p.peek() + if id == LEFT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: LEFT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: LEFT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: LEFT openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == RIGHT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: RIGHT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: RIGHT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: RIGHT openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == FORMAT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: FORMAT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: FORMAT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: FORMAT openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == GROUPING { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: GROUPING <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: GROUPING openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: GROUPING openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == SCHEMA { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: SCHEMA <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_keyword: SCHEMA openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1))}, true + } else if id == CONVERT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: CONVERT <'('>', found: '" + string(tok) + "'") + } + var5, ok := p.convertType() + if !ok { + p.fail("expected: 'function_call_keyword: CONVERT openb expression ',' ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: CONVERT openb expression ',' convert_type <')'>', found: '" + string(tok) + "'") + } + return &ConvertExpr{Name: string(var1), Expr: var3, Type: var5}, true + } else if id == CAST { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: CAST <'('>', found: '" + string(tok) + "'") + } + var4, tok := p.next() + if var4 != AS { + p.fail("expected: 'function_call_keyword: CAST openb expression ', found: '" + string(tok) + "'") + } + var5, ok := p.convertType() + if !ok { + p.fail("expected: 'function_call_keyword: CAST openb expression AS ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: CAST openb expression AS convert_type <')'>', found: '" + string(tok) + "'") + } + return &ConvertExpr{Name: string(var1), Expr: var3, Type: var5}, true + } else if id == CHAR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: CHAR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: CHAR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: CHAR openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &CharExpr{Exprs: var3}, true + } else if id == CHAR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: CHAR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: CHAR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != USING { + p.fail("expected: 'function_call_keyword: CHAR openb argument_expression_list ', found: '" + string(tok) + "'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: CHAR openb argument_expression_list USING charset <')'>', found: '" + string(tok) + "'") + } + return &CharExpr{Exprs: var3, Type: var5}, true + } else if id == CONVERT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: CONVERT <'('>', found: '" + string(tok) + "'") + } + var4, tok := p.next() + if var4 != USING { + p.fail("expected: 'function_call_keyword: CONVERT openb expression ', found: '" + string(tok) + "'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: CONVERT openb expression USING charset <')'>', found: '" + string(tok) + "'") + } + return &ConvertUsingExpr{Expr: var3, Type: var5}, true + } else if id == POSITION { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: POSITION <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: POSITION openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != IN { + p.fail("expected: 'function_call_keyword: POSITION openb value_expression ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: POSITION openb value_expression IN ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: POSITION openb value_expression IN value_expression <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent("LOCATE"), Exprs: []SelectExpr{&AliasedExpr{Expr: var3}, &AliasedExpr{Expr: var5}}}, true + } else if id == INSERT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: INSERT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: INSERT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: INSERT openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == SUBSTR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: SUBSTR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.columnName() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_keyword: SUBSTR openb column_name ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTR openb column_name FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != FOR { + p.fail("expected: 'function_call_keyword: SUBSTR openb column_name FROM value_expression ', found: '" + string(tok) + "'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTR openb column_name FROM value_expression FOR ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_keyword: SUBSTR openb column_name FROM value_expression FOR value_expression <')'>', found: '" + string(tok) + "'") + } + return &SubstrExpr{Name: var3, From: var5, To: var7}, true + } else if id == SUBSTRING { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: SUBSTRING <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.columnName() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTRING openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_keyword: SUBSTRING openb column_name ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTRING openb column_name FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != FOR { + p.fail("expected: 'function_call_keyword: SUBSTRING openb column_name FROM value_expression ', found: '" + string(tok) + "'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTRING openb column_name FROM value_expression FOR ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_keyword: SUBSTRING openb column_name FROM value_expression FOR value_expression <')'>', found: '" + string(tok) + "'") + } + return &SubstrExpr{Name: var3, From: var5, To: var7}, true + } else if id == SUBSTR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: SUBSTR <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != STRING { + p.fail("expected: 'function_call_keyword: SUBSTR openb ', found: '" + string(tok) + "'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_keyword: SUBSTR openb STRING ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTR openb STRING FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != FOR { + p.fail("expected: 'function_call_keyword: SUBSTR openb STRING FROM value_expression ', found: '" + string(tok) + "'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTR openb STRING FROM value_expression FOR ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_keyword: SUBSTR openb STRING FROM value_expression FOR value_expression <')'>', found: '" + string(tok) + "'") + } + return &SubstrExpr{StrVal: NewStrVal(var3), From: var5, To: var7}, true + } else if id == SUBSTRING { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: SUBSTRING <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != STRING { + p.fail("expected: 'function_call_keyword: SUBSTRING openb ', found: '" + string(tok) + "'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_keyword: SUBSTRING openb STRING ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTRING openb STRING FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != FOR { + p.fail("expected: 'function_call_keyword: SUBSTRING openb STRING FROM value_expression ', found: '" + string(tok) + "'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: SUBSTRING openb STRING FROM value_expression FOR ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_keyword: SUBSTRING openb STRING FROM value_expression FOR value_expression <')'>', found: '" + string(tok) + "'") + } + return &SubstrExpr{StrVal: NewStrVal(var3), From: var5, To: var7}, true + } else if id == TRIM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: TRIM <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: TRIM openb value_expression <')'>', found: '" + string(tok) + "'") + } + return &TrimExpr{Pattern: NewStrVal([]byte(" ")), Str: var3, Dir: Both}, true + } else if id == TRIM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: TRIM <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_keyword: TRIM openb value_expression ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb value_expression FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_keyword: TRIM openb value_expression FROM value_expression <')'>', found: '" + string(tok) + "'") + } + return &TrimExpr{Pattern: var3, Str: var5, Dir: Both}, true + } else if id == TRIM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: TRIM <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != LEADING { + p.fail("expected: 'function_call_keyword: TRIM openb ', found: '" + string(tok) + "'") + } + var4, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb LEADING ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != FROM { + p.fail("expected: 'function_call_keyword: TRIM openb LEADING value_expression ', found: '" + string(tok) + "'") + } + var6, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb LEADING value_expression FROM ', found: 'string(tok)'") + } + var7, tok := p.next() + if var7 != ')' { + p.fail("expected: 'function_call_keyword: TRIM openb LEADING value_expression FROM value_expression <')'>', found: '" + string(tok) + "'") + } + return &TrimExpr{Pattern: var4, Str: var6, Dir: Leading}, true + } else if id == TRIM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: TRIM <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != TRAILING { + p.fail("expected: 'function_call_keyword: TRIM openb ', found: '" + string(tok) + "'") + } + var4, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb TRAILING ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != FROM { + p.fail("expected: 'function_call_keyword: TRIM openb TRAILING value_expression ', found: '" + string(tok) + "'") + } + var6, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb TRAILING value_expression FROM ', found: 'string(tok)'") + } + var7, tok := p.next() + if var7 != ')' { + p.fail("expected: 'function_call_keyword: TRIM openb TRAILING value_expression FROM value_expression <')'>', found: '" + string(tok) + "'") + } + return &TrimExpr{Pattern: var4, Str: var6, Dir: Trailing}, true + } else if id == TRIM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: TRIM <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != BOTH { + p.fail("expected: 'function_call_keyword: TRIM openb ', found: '" + string(tok) + "'") + } + var4, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb BOTH ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != FROM { + p.fail("expected: 'function_call_keyword: TRIM openb BOTH value_expression ', found: '" + string(tok) + "'") + } + var6, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: TRIM openb BOTH value_expression FROM ', found: 'string(tok)'") + } + var7, tok := p.next() + if var7 != ')' { + p.fail("expected: 'function_call_keyword: TRIM openb BOTH value_expression FROM value_expression <')'>', found: '" + string(tok) + "'") + } + return &TrimExpr{Pattern: var4, Str: var6, Dir: Both}, true + } else if id == MATCH { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: MATCH <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: MATCH openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, tok := p.next() + if var5 != AGAINST { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list closeb ', found: '" + string(tok) + "'") + } + var6, tok := p.next() + if var6 != '(' { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list closeb AGAINST <'('>', found: '" + string(tok) + "'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list closeb AGAINST openb ', found: 'string(tok)'") + } + var8, ok := p.matchOption() + if !ok { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list closeb AGAINST openb value_expression ', found: 'string(tok)'") + } + var9, tok := p.next() + if var9 != ')' { + p.fail("expected: 'function_call_keyword: MATCH openb argument_expression_list closeb AGAINST openb value_expression match_option <')'>', found: '" + string(tok) + "'") + } + return &MatchExpr{Columns: var3, Expr: var7, Option: var8}, true + } else if id == FIRST { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: FIRST <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: FIRST openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: FIRST openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == GROUP_CONCAT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT openb distinct_opt ', found: 'string(tok)'") + } + var5, ok := p.orderByOpt() + if !ok { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT openb distinct_opt argument_expression_list ', found: 'string(tok)'") + } + var6, ok := p.separatorOpt() + if !ok { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT openb distinct_opt argument_expression_list order_by_opt ', found: 'string(tok)'") + } + var7, tok := p.next() + if var7 != ')' { + p.fail("expected: 'function_call_keyword: GROUP_CONCAT openb distinct_opt argument_expression_list order_by_opt separator_opt <')'>', found: '" + string(tok) + "'") + } + return &GroupConcatExpr{Distinct: var3, Exprs: var4, OrderBy: var5, Separator: var6}, true + } else if id == CASE { + var1, _ := p.next() + var2, ok := p.expressionOpt() + if !ok { + p.fail("expected: 'function_call_keyword: CASE ', found: 'string(tok)'") + } + var3, ok := p.whenExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: CASE expression_opt ', found: 'string(tok)'") + } + var4, ok := p.elseExpressionOpt() + if !ok { + p.fail("expected: 'function_call_keyword: CASE expression_opt when_expression_list ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != END { + p.fail("expected: 'function_call_keyword: CASE expression_opt when_expression_list else_expression_opt ', found: '" + string(tok) + "'") + } + return &CaseExpr{Expr: var2, Whens: var3, Else: var4}, true + } else if id == VALUES { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: VALUES <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.columnName() + if !ok { + p.fail("expected: 'function_call_keyword: VALUES openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: VALUES openb column_name <')'>', found: '" + string(tok) + "'") + } + return &ValuesFuncExpr{Name: var3}, true + } else if id == VALUES { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: VALUES <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.columnNameSafeKeyword() + if !ok { + p.fail("expected: 'function_call_keyword: VALUES openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: VALUES openb column_name_safe_keyword <')'>', found: '" + string(tok) + "'") + } + return &ValuesFuncExpr{Name: NewColName(string(var3))}, true + } else if id == VALUES { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: VALUES <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.nonReservedKeyword3() + if !ok { + p.fail("expected: 'function_call_keyword: VALUES openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: VALUES openb non_reserved_keyword3 <')'>', found: '" + string(tok) + "'") + } + return &ValuesFuncExpr{Name: NewColName(string(var3))}, true + } else if id == REPEAT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_keyword: REPEAT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_keyword: REPEAT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_keyword: REPEAT openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } + return nil, false +} +func (p *parser) functionCallWindow() (Expr, bool) { + id, tok := p.peek() + if id == CUME_DIST { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: CUME_DIST <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: CUME_DIST openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } else if id == DENSE_RANK { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: DENSE_RANK <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: DENSE_RANK openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } else if id == FIRST_VALUE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: FIRST_VALUE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpression() + if !ok { + p.fail("expected: 'function_call_window: FIRST_VALUE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_window: FIRST_VALUE openb argument_expression <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: SelectExprs{var3}, Over: var5}, true + } else if id == LAG { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: LAG <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_window: LAG openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_window: LAG openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == LAST_VALUE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: LAST_VALUE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpression() + if !ok { + p.fail("expected: 'function_call_window: LAST_VALUE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_window: LAST_VALUE openb argument_expression <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: SelectExprs{var3}, Over: var5}, true + } else if id == LEAD { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: LEAD <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_window: LEAD openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_window: LEAD openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == NTH_VALUE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: NTH_VALUE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_window: NTH_VALUE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_window: NTH_VALUE openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == NTILE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: NTILE <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: NTILE openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } else if id == PERCENT_RANK { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: PERCENT_RANK <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: PERCENT_RANK openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } else if id == RANK { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: RANK <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: RANK openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } else if id == ROW_NUMBER { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_window: ROW_NUMBER <'('>', found: '" + string(tok) + "'") + } + var3, tok := p.next() + if var3 != ')' { + p.fail("expected: 'function_call_window: ROW_NUMBER openb <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Over: var4}, true + } + return nil, false +} +func (p *parser) functionCallAggregateWithWindow() (Expr, bool) { + id, tok := p.peek() + if id == MAX { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: MAX <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MAX openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MAX openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: MAX openb distinct_opt argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var6, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MAX openb distinct_opt argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var4, Distinct: var3 == DistinctStr, Over: var6}, true + } else if id == AVG { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: AVG <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: AVG openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: AVG openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: AVG openb distinct_opt argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var6, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: AVG openb distinct_opt argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var4, Distinct: var3 == DistinctStr, Over: var6}, true + } else if id == BIT_AND { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_AND <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_AND openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_AND openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_AND openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == BIT_OR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_OR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_OR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_OR openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_OR openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == BIT_XOR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_XOR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_XOR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: BIT_XOR openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: BIT_XOR openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == COUNT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: COUNT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: COUNT openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: COUNT openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: COUNT openb distinct_opt argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var6, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: COUNT openb distinct_opt argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var4, Distinct: var3 == DistinctStr, Over: var6}, true + } else if id == JSON_ARRAYAGG { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: JSON_ARRAYAGG <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: JSON_ARRAYAGG openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: JSON_ARRAYAGG openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: JSON_ARRAYAGG openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == JSON_OBJECTAGG { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: JSON_OBJECTAGG <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: JSON_OBJECTAGG openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: JSON_OBJECTAGG openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: JSON_OBJECTAGG openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == MIN { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: MIN <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MIN openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MIN openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: MIN openb distinct_opt argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var6, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: MIN openb distinct_opt argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var4, Distinct: var3 == DistinctStr, Over: var6}, true + } else if id == STDDEV_POP { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_POP <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_POP openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_POP openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_POP openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == STDDEV { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == STD { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: STD <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STD openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: STD openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STD openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == STDDEV_SAMP { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_SAMP <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_SAMP openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_SAMP openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: STDDEV_SAMP openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == SUM { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: SUM <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: SUM openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: SUM openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: SUM openb distinct_opt argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var6, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: SUM openb distinct_opt argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var4, Distinct: var3 == DistinctStr, Over: var6}, true + } else if id == VAR_POP { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: VAR_POP <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VAR_POP openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: VAR_POP openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VAR_POP openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == VARIANCE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: VARIANCE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VARIANCE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: VARIANCE openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VARIANCE openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } else if id == VAR_SAMP { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_aggregate_with_window: VAR_SAMP <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VAR_SAMP openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_aggregate_with_window: VAR_SAMP openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + var5, ok := p.overOpt() + if !ok { + p.fail("expected: 'function_call_aggregate_with_window: VAR_SAMP openb argument_expression_list closeb ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3, Over: var5}, true + } + return nil, false +} +func (p *parser) functionCallConflict() (Expr, bool) { + id, tok := p.peek() + if id == IF { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: IF <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_conflict: IF openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: IF openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == DATABASE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: DATABASE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionListOpt() + if !ok { + p.fail("expected: 'function_call_conflict: DATABASE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: DATABASE openb argument_expression_list_opt <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == MOD { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: MOD <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_conflict: MOD openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: MOD openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == REPLACE { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: REPLACE <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_conflict: REPLACE openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: REPLACE openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == SUBSTR { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: SUBSTR <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_conflict: SUBSTR openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: SUBSTR openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: var3}, true + } else if id == SUBSTRING { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_conflict: SUBSTRING <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.argumentExpressionList() + if !ok { + p.fail("expected: 'function_call_conflict: SUBSTRING openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != ')' { + p.fail("expected: 'function_call_conflict: SUBSTRING openb argument_expression_list <')'>', found: '" + string(tok) + "'") + } + return &varvar, true + } + return nil, false +} +func (p *parser) functionCallNonkeyword() (Expr, bool) { + id, tok := p.peek() + if id == CURRENT_DATE { + var1, _ := p.next() + var2, ok := p.funcParensOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: CURRENT_DATE ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1))}, true + } else if id == CURRENT_USER { + var1, _ := p.next() + var2, ok := p.funcParensOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: CURRENT_USER ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1))}, true + } else if id == UTC_DATE { + var1, _ := p.next() + var2, ok := p.funcParensOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: UTC_DATE ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1))}, true + } else if _, ok := p.functionCallOnUpdate(); ok { + return &var1, true + } else if id == CURRENT_TIME { + var1, _ := p.next() + var2, ok := p.funcDatetimePrecOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: CURRENT_TIME ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: SelectExprs{&AliasedExpr{Expr: var2}}}, true + } else if id == UTC_TIME { + var1, _ := p.next() + var2, ok := p.funcDatetimePrecOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: UTC_TIME ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: SelectExprs{&AliasedExpr{Expr: var2}}}, true + } else if id == UTC_TIMESTAMP { + var1, _ := p.next() + var2, ok := p.funcDatetimePrecOpt() + if !ok { + p.fail("expected: 'function_call_nonkeyword: UTC_TIMESTAMP ', found: 'string(tok)'") + } + return &FuncExpr{Name: NewColIdent(string(var1)), Exprs: SelectExprs{&AliasedExpr{Expr: var2}}}, true + } else if id == TIMESTAMPADD { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPADD <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.timeUnit() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPADD openb ', found: 'string(tok)'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPADD openb time_unit ',' ', found: 'string(tok)'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPADD openb time_unit ',' value_expression ',' ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPADD openb time_unit ',' value_expression ',' value_expression <')'>', found: '" + string(tok) + "'") + } + return &TimestampFuncExpr{Name:string("timestampadd"), Unit:string(var3), Expr1:var5, Expr2:var7}, true + } else if id == TIMESTAMPDIFF { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPDIFF <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.timeUnit() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPDIFF openb ', found: 'string(tok)'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPDIFF openb time_unit ',' ', found: 'string(tok)'") + } + var7, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPDIFF openb time_unit ',' value_expression ',' ', found: 'string(tok)'") + } + var8, tok := p.next() + if var8 != ')' { + p.fail("expected: 'function_call_nonkeyword: TIMESTAMPDIFF openb time_unit ',' value_expression ',' value_expression <')'>', found: '" + string(tok) + "'") + } + return &TimestampFuncExpr{Name:string("timestampdiff"), Unit:string(var3), Expr1:var5, Expr2:var7}, true + } else if id == EXTRACT { + var1, _ := p.next() + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_nonkeyword: EXTRACT <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.timeUnit() + if !ok { + p.fail("expected: 'function_call_nonkeyword: EXTRACT openb ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != FROM { + p.fail("expected: 'function_call_nonkeyword: EXTRACT openb time_unit ', found: '" + string(tok) + "'") + } + var5, ok := p.valueExpression() + if !ok { + p.fail("expected: 'function_call_nonkeyword: EXTRACT openb time_unit FROM ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_nonkeyword: EXTRACT openb time_unit FROM value_expression <')'>', found: '" + string(tok) + "'") + } + return &ExtractFuncExpr{Name: string(var1), Unit: string(var3), Expr: var5}, true + } + return nil, false +} +func (p *parser) functionCallGeneric() (Expr, bool) { + id, tok := p.peek() + if _, ok := p.sqlId(); ok { + var2, tok := p.next() + if var2 != '(' { + p.fail("expected: 'function_call_generic: sql_id <'('>', found: '" + string(tok) + "'") + } + var3, ok := p.distinctOpt() + if !ok { + p.fail("expected: 'function_call_generic: sql_id openb ', found: 'string(tok)'") + } + var4, ok := p.argumentExpressionListOpt() + if !ok { + p.fail("expected: 'function_call_generic: sql_id openb distinct_opt ', found: 'string(tok)'") + } + var5, tok := p.next() + if var5 != ')' { + p.fail("expected: 'function_call_generic: sql_id openb distinct_opt argument_expression_list_opt <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Name: var1, Distinct: var3 == DistinctStr, Exprs: var4}, true + } else if _, ok := p.tableId(); ok { + var3, ok := p.reservedSqlId() + if !ok { + p.fail("expected: 'function_call_generic: table_id '.' ', found: 'string(tok)'") + } + var4, tok := p.next() + if var4 != '(' { + p.fail("expected: 'function_call_generic: table_id '.' reserved_sql_id <'('>', found: '" + string(tok) + "'") + } + var5, ok := p.argumentExpressionListOpt() + if !ok { + p.fail("expected: 'function_call_generic: table_id '.' reserved_sql_id openb ', found: 'string(tok)'") + } + var6, tok := p.next() + if var6 != ')' { + p.fail("expected: 'function_call_generic: table_id '.' reserved_sql_id openb argument_expression_list_opt <')'>', found: '" + string(tok) + "'") + } + return &FuncExpr{Qualifier: var1, Name: var3, Exprs: var5}, true + } + return nil, false +} From 81d4a2664fa2024cf08c30a617c5b209ad864465 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Tue, 17 Sep 2024 13:47:33 -0700 Subject: [PATCH 02/14] break up yacc file into sections --- go/vt/sqlparser/gen/cmd/main.go | 12 +- go/vt/sqlparser/gen/rd/split.go | 187 +++++++++++++++++++++ go/vt/sqlparser/gen/rd/split_test.go | 234 +++++++++++++++++++++++++++ 3 files changed, 423 insertions(+), 10 deletions(-) create mode 100644 go/vt/sqlparser/gen/rd/split.go create mode 100644 go/vt/sqlparser/gen/rd/split_test.go diff --git a/go/vt/sqlparser/gen/cmd/main.go b/go/vt/sqlparser/gen/cmd/main.go index 2f06fcb070f..a958a885329 100644 --- a/go/vt/sqlparser/gen/cmd/main.go +++ b/go/vt/sqlparser/gen/cmd/main.go @@ -71,16 +71,6 @@ func (p *pgen) gen() (string, error) { b := strings.Builder{} fmt.Fprintf(&b, "package sqlparser\n\n") - //l, ok := p.nextLine() - //if !ok { - // return "", fmt.Errorf("function id invalid") - //} - //fid := strings.Split(l, ":") - //if len(fid) < 1 { - // return "", fmt.Errorf("function id invalid") - //} - //fmt.Fprintf(&b, "func (p *parser) %s() (Expr, bool) {\n", camelize(fid[0])) - //fmt.Fprintf(&b, " id, tok := p.peek()\n") topIfElse := " if" currentFname := "" for { @@ -136,10 +126,12 @@ func (p *pgen) gen() (string, error) { if i == 0 { if cmp != "" { fmt.Fprintf(&b, "%s id == %s {\n", topIfElse, cmp) + fmt.Fprintf(&b, " // %s\n", def) fmt.Fprintf(&b, " var1, _ := p.next()\n") } else { fname := camelize(p) fmt.Fprintf(&b, "%s var1, ok := p.%s(); ok {\n", topIfElse, fname) + fmt.Fprintf(&b, " // %s\n", def) } topIfElse = " else if" continue diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go new file mode 100644 index 00000000000..15223210d0c --- /dev/null +++ b/go/vt/sqlparser/gen/rd/split.go @@ -0,0 +1,187 @@ +package rd + +import ( + "bufio" + "fmt" + "io" + "strings" +) + +// split yacc file into individual functions +// remove comments +// split + +type yaccFileContents struct { + prefix []string + goTypes []goType + yaccTypes []yaccType + tokens []yaccToken + start string + defs []*def +} + +type goType struct { + name string + typ string +} + +type yaccType struct { + name string + typ string +} + +type yaccToken struct { + name string + yaccTyp string +} + +type def struct { + name string + rules []*rule +} + +type rule struct { + name string + start bool + body []string +} + +func split(infile io.Reader) (*yaccFileContents, error) { + sc := bufio.NewScanner(infile) + var buf []string + var acc bool + var d *def + var r *rule + var err error + var nesting int + yc := new(yaccFileContents) + for sc.Scan() { + line := sc.Text() + line = strings.TrimSpace(line) + if len(line) == 0 { + continue + } + switch line { + case "{": + if r == nil { + r = new(rule) + } + r.start = true + + continue + case "%{": + acc = true + continue + case "%}": + yc.prefix = buf + buf = nil + acc = false + continue + case "%union {": + acc = true + continue + case "}": + if nesting > 0 { + nesting-- + } else if d != nil { + d.rules = append(d.rules, r) + r = nil + continue + } else { + yc.goTypes, err = parseGoTypes(buf) + if err != nil { + return nil, err + } + buf = nil + acc = false + continue + } + case "%%": + continue + } + + if acc { + buf = append(buf, line) + } + + if strings.HasPrefix(line, "%left") { + } else if strings.HasPrefix(line, "%type") { + yaccTyp, err := parseYaccType(line) + if err != nil { + return nil, err + } + yc.yaccTypes = append(yc.yaccTypes, yaccTyp...) + } else if strings.HasPrefix(line, "%token") { + //yc.tokens = append(yc.tokens, line) + continue + } else if strings.HasPrefix(line, "%right") { + + } else if strings.HasPrefix(line, "%nonassoc") { + } else if strings.HasPrefix(line, "%start") { + yc.start = strings.Split(line, " ")[1] + } else if strings.HasPrefix(line, "|") && r != nil { + d.rules = append(d.rules, r) + r = nil + } + + if line[len(line)-1] == ':' { + if d != nil { + yc.defs = append(yc.defs, d) + } + d = new(def) + d.name = line[:len(line)-1] + continue + } + if r != nil { + if line[len(line)-1] == '{' { + nesting++ + } + r.body = append(r.body, line) + } else if d != nil { + r = new(rule) + r.name = parseRuleName(line) + } + } + if d != nil { + yc.defs = append(yc.defs, d) + } + return yc, nil +} + +func parseRuleName(s string) string { + s = strings.TrimSpace(s) + if s[0] == '|' { + s = s[1:] + } + s = strings.TrimSpace(s) + return s +} + +func parseGoTypes(in []string) ([]goType, error) { + var ret []goType + for _, typ := range in { + parts := strings.Fields(typ) + if len(parts) != 2 { + return nil, fmt.Errorf("invalid go type: %s", typ) + } + ret = append(ret, goType{name: parts[0], typ: parts[1]}) + } + return ret, nil +} + +func parseYaccType(in string) ([]yaccType, error) { + parts := strings.Split(in, " ") + if parts[0] != "%type" || len(parts) < 3 { + return nil, fmt.Errorf("invalid yacc type: %s", in) + } + name := parts[1] + if name[0] != '<' || name[len(name)-1] != '>' { + return nil, fmt.Errorf("invalid yacc type: %s", in) + } + name = name[1 : len(name)-1] + var ret []yaccType + for _, p := range parts[2:] { + ret = append(ret, yaccType{name: name, typ: p}) + } + return ret, nil +} diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go new file mode 100644 index 00000000000..afc28309afa --- /dev/null +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -0,0 +1,234 @@ +package rd + +import ( + "github.com/stretchr/testify/require" + "strings" + "testing" +) + +var testY = ` + +%{ +package sqlparser + +import "fmt" +import "strings" +%} + +%union { + empty struct{} + statement Statement + selStmt SelectStatement + ddl *DDL +} + +// comment + +%token NEXT VALUE SHARE MODE +%token SQL_NO_CACHE SQL_CACHE + +%type row_tuple tuple_or_empty +%type tuple_expression + +%start any_command + +%% + +any_command: + command + { + setParseTree(yylex, $1) + } +| command ';' + { + setParseTree(yylex, $1) + statementSeen(yylex) + } + + +command: + select_statement + { + $$ = $1 + } +| values_select_statement + { + $$ = $1 + } +| stream_statement +| insert_statement +| /*empty*/ +{ + setParseTree(yylex, nil) +} + +set_opt: + { + $$ = nil + } +| SET assignment_list + { + $$ = $2 + } +load_statement: + LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt + { + $$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13} + } + +select_statement: + with_select order_by_opt limit_opt lock_opt into_opt + { + $1.SetOrderBy($2) + $1.SetLimit($3) + $1.SetLock($4) + if err := $1.SetInto($5); err != nil { + yylex.Error(err.Error()) + return 1 + } + $$ = $1 + } +| SELECT comment_opt query_opts NEXT num_val for_from table_name + { + $$ = &Select{ + Comments: Comments($2), + QueryOpts: $3, + SelectExprs: SelectExprs{Nextval{Expr: $5}}, + From: TableExprs{&AliasedTableExpr{Expr: $7}}, + } + } + +` + +func TestGen(t *testing.T) { + inp := strings.NewReader(testY) + cmp, err := split(inp) +} + +func TestSplit(t *testing.T) { + inp := strings.NewReader(testY) + cmp, err := split(inp) + require.NoError(t, err) + exp := &yaccFileContents{ + prefix: []string{ + "package sqlparser", + "import \"fmt\"", + "import \"strings\"", + }, + goTypes: []goType{ + {name: "empty", typ: "struct{}"}, + {name: "statement", typ: "Statement"}, + {name: "selStmt", typ: "SelectStatement"}, + {name: "ddl", typ: "*DDL"}, + }, + yaccTypes: []yaccType{ + {name: "valTuple", typ: "row_tuple"}, + {name: "valTuple", typ: "tuple_or_empty"}, + {name: "expr", typ: "tuple_expression"}, + }, + tokens: nil, + start: "any_command", + defs: []*def{ + { + name: "any_command", + rules: []*rule{ + { + name: "command", + start: true, + body: []string{"setParseTree(yylex, $1)"}, + }, + { + name: "command ';'", + start: true, + body: []string{"setParseTree(yylex, $1)", "statementSeen(yylex)"}, + }, + }, + }, + { + name: "command", + rules: []*rule{ + { + name: "select_statement", + start: true, + body: []string{"$$ = $1"}, + }, + { + name: "values_select_statement", + start: true, + body: []string{"$$ = $1"}, + }, + { + name: "stream_statement", + }, + { + name: "insert_statement", + }, + { + name: "/*empty*/", + start: true, + body: []string{"setParseTree(yylex, nil)"}, + }, + }, + }, + { + name: "set_opt", + rules: []*rule{ + { + name: "", + start: true, + body: []string{"$$ = nil"}, + }, + { + name: "SET assignment_list", + start: true, + body: []string{"$$ = $2"}, + }, + }, + }, + { + name: "load_statement", + rules: []*rule{ + { + name: "LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt", + start: true, + body: []string{ + "$$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13}"}, + }, + }, + }, + { + name: "select_statement", + rules: []*rule{ + { + name: "with_select order_by_opt limit_opt lock_opt into_opt", + start: true, + body: []string{ + "$1.SetOrderBy($2)", + "$1.SetLimit($3)", + "$1.SetLock($4)", + "if err := $1.SetInto($5); err != nil {", + "yylex.Error(err.Error())", + "return 1", + "}", + "$$ = $1", + }, + }, + { + name: "SELECT comment_opt query_opts NEXT num_val for_from table_name", + start: true, + body: []string{ + "$$ = &Select{", + "Comments: Comments($2),", + "QueryOpts: $3,", + "SelectExprs: SelectExprs{Nextval{Expr: $5}},", + "From: TableExprs{&AliasedTableExpr{Expr: $7}},", + "}", + }, + }, + }, + }, + }, + } + + require.Equal(t, exp, cmp) +} From 1c2cc3f29754d4707544543072982cdaf04db77a Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Tue, 17 Sep 2024 21:03:17 -0700 Subject: [PATCH 03/14] progress --- go/vt/sqlparser/gen/rd/generator.go | 147 +++++++++++++++++++++++++++ go/vt/sqlparser/gen/rd/split.go | 11 +- go/vt/sqlparser/gen/rd/split_test.go | 24 ++++- 3 files changed, 176 insertions(+), 6 deletions(-) create mode 100644 go/vt/sqlparser/gen/rd/generator.go diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go new file mode 100644 index 00000000000..a2ebd4a6be3 --- /dev/null +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -0,0 +1,147 @@ +package rd + +import ( + "fmt" + "io" + "strings" +) + +// generator splits yacc file +// and then codegen's recursive descent +// create mappings for expression types +// gen prefix +// gen all of the functions, using lookups for function name and types + +type recursiveGen struct { + inf io.Reader + b *strings.Builder + outf io.Writer + yacc *yaccFileContents + goTypes map[string]string + funcExprs map[string]string +} + +func newRecursiveGen(inf io.Reader, outf io.Writer) *recursiveGen { + return &recursiveGen{ + inf: inf, + outf: outf, + b: &strings.Builder{}, + goTypes: make(map[string]string), + funcExprs: make(map[string]string), + } +} + +func (g *recursiveGen) init() (err error) { + g.yacc, err = split(g.inf) + if err != nil { + return err + } + if g.goTypes == nil { + g.goTypes = make(map[string]string) + } + if g.funcExprs == nil { + g.funcExprs = make(map[string]string) + } + for _, typ := range g.yacc.goTypes { + g.goTypes[typ.name] = typ.typ + } + for _, d := range g.yacc.yaccTypes { + goTyp, ok := g.goTypes[d.typ] + if !ok { + return fmt.Errorf("function expression not found: %s", d.name) + } + g.funcExprs[d.name] = goTyp + } + return nil +} + +func (g *recursiveGen) gen() error { + if g.yacc == nil { + return fmt.Errorf("missing parsed yacc contents") + } + // prefix + if err := g.genPrefix(); err != nil { + return err + } + if err := g.genStart(); err != nil { + return err + } + // each function + for _, d := range g.yacc.defs { + if err := g.genFunc(d); err != nil { + return err + } + } + return nil +} + +func (g *recursiveGen) genPrefix() error { + for _, line := range g.yacc.prefix { + fmt.Fprintln(g.b, line) + } + return nil +} + +func (g *recursiveGen) genStart() error { + start := g.yacc.start + if start == "" { + return fmt.Errorf("start function not found") + } + fmt.Fprintf(g.b, "func (p *parser) parse() (statement, bool) {\n") + fmt.Fprintf(g.b, " return %s()\n", g.yacc.start) + fmt.Fprintf(g.b, "}\n\n") + return nil +} + +func (g *recursiveGen) genFunc(d *def) error { + fmt.Fprintf(g.b, "func (p *parser) %s() (Expr, bool) {\n", d.name) + fmt.Fprintf(g.b, " id, tok := p.peek()\n") + for i, r := range d.rules { + parts := strings.Fields(r.name) + for j, p := range parts { + var cmp string + if p == "openb" { + cmp = "'('" + } else if p == "closeb" { + cmp = "')'" + } else if _, ok := g.funcExprs[p]; ok { + } else { + cmp = p + } + if j == 0 { + if i == 0 { + fmt.Fprintf(g.b, " if ") + } else { + fmt.Fprintf(g.b, "} else if ") + } + if cmp != "" { + fmt.Fprintf(g.b, "id == %s {\n", cmp) + fmt.Fprintf(g.b, " // %s\n", r.name) + fmt.Fprintf(g.b, " var1, _ := p.next()\n") + } else { + fmt.Fprintf(g.b, "var1, ok := p.%s(); ok {\n", p) + fmt.Fprintf(g.b, " // %s\n", r.name) + } + continue + } + if cmp != "" { + fmt.Fprintf(g.b, " var%d, tok := p.next()\n", j+1) + fmt.Fprintf(g.b, " if var%d != %s {\n", j+1, cmp) + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp) + fmt.Fprintf(g.b, " }\n") + } else if _, ok := g.funcExprs[p]; ok { + fmt.Fprintf(g.b, " var%d, ok := p.%s()\n", j+1, p) + fmt.Fprintf(g.b, " if !ok {\n") + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok)'\")\n", p, strings.Join(parts[:j], " "), p) + fmt.Fprintf(g.b, " }\n") + } + } + //success, return + for _, r := range r.body { + fmt.Fprintf(g.b, " %s\n", r) + } + fmt.Fprintf(g.b, " }\n") + } + fmt.Fprintf(g.b, "\n return nil, false\n}\n") + return nil +} diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 15223210d0c..516298e7297 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -101,6 +101,9 @@ func split(infile io.Reader) (*yaccFileContents, error) { } if acc { + if line[len(line)-1] == '{' { + nesting++ + } buf = append(buf, line) } @@ -174,14 +177,14 @@ func parseYaccType(in string) ([]yaccType, error) { if parts[0] != "%type" || len(parts) < 3 { return nil, fmt.Errorf("invalid yacc type: %s", in) } - name := parts[1] - if name[0] != '<' || name[len(name)-1] != '>' { + typ := parts[1] + if typ[0] != '<' || typ[len(typ)-1] != '>' { return nil, fmt.Errorf("invalid yacc type: %s", in) } - name = name[1 : len(name)-1] + typ = typ[1 : len(typ)-1] var ret []yaccType for _, p := range parts[2:] { - ret = append(ret, yaccType{name: name, typ: p}) + ret = append(ret, yaccType{name: p, typ: typ}) } return ret, nil } diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index afc28309afa..81c6779cda1 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -2,6 +2,8 @@ package rd import ( "github.com/stretchr/testify/require" + "io" + "os" "strings" "testing" ) @@ -100,9 +102,27 @@ select_statement: ` +type emptyWriter struct{} + +var _ io.Writer = (*emptyWriter)(nil) + +func (e emptyWriter) Write(p []byte) (n int, err error) { + return 0, nil +} + func TestGen(t *testing.T) { - inp := strings.NewReader(testY) - cmp, err := split(inp) + inp, err := os.Open("../../sql.y") + require.NoError(t, err) + //inp := strings.NewReader(testY) + g := newRecursiveGen(inp, emptyWriter{}) + err = g.init() + require.NoError(t, err) + err = g.gen() + require.NoError(t, err) + outfile, err := os.OpenFile("sql.gen.go", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) + require.NoError(t, err) + _, err = io.Copy(outfile, strings.NewReader(g.b.String())) + require.NoError(t, err) } func TestSplit(t *testing.T) { From f49b3c2126c9c1031c7eb8dec1397339f5c697ae Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Thu, 19 Sep 2024 09:56:44 -0700 Subject: [PATCH 04/14] prog --- go/vt/sqlparser/gen/rd/generator.go | 157 ++++++++++++++++++++++++--- go/vt/sqlparser/gen/rd/split.go | 11 ++ go/vt/sqlparser/gen/rd/split_test.go | 25 ++++- go/vt/sqlparser/sql.y | 11 +- 4 files changed, 176 insertions(+), 28 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index a2ebd4a6be3..4436214354f 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -3,6 +3,9 @@ package rd import ( "fmt" "io" + "log" + "regexp" + "strconv" "strings" ) @@ -76,6 +79,10 @@ func (g *recursiveGen) gen() error { } func (g *recursiveGen) genPrefix() error { + fmt.Fprintln(g.b, "package sqlparser") + fmt.Fprintln(g.b, "import \"fmt\"") + fmt.Fprintln(g.b, "import \"strings\"") + return nil for _, line := range g.yacc.prefix { fmt.Fprintln(g.b, line) } @@ -83,43 +90,100 @@ func (g *recursiveGen) genPrefix() error { } func (g *recursiveGen) genStart() error { + return nil start := g.yacc.start if start == "" { return fmt.Errorf("start function not found") } - fmt.Fprintf(g.b, "func (p *parser) parse() (statement, bool) {\n") - fmt.Fprintf(g.b, " return %s()\n", g.yacc.start) + fmt.Fprintf(g.b, "func (p *parser) parse(yylex *Tokenizer) (Expr, bool) {\n") + fmt.Fprintf(g.b, " return p.%s(yylex)\n", g.yacc.start) fmt.Fprintf(g.b, "}\n\n") return nil } func (g *recursiveGen) genFunc(d *def) error { - fmt.Fprintf(g.b, "func (p *parser) %s() (Expr, bool) {\n", d.name) - fmt.Fprintf(g.b, " id, tok := p.peek()\n") - for i, r := range d.rules { + typ, ok := g.funcExprs[d.name] + if !ok { + log.Printf("function type not found: %s\n", d.name) + typ = "[]byte" + } + //switch d.name { + //case "lexer_old_position", "lexer_position", "special_comment_mode": + // return nil + //} + if d.name == "view_name_list" { + print() + } + fmt.Fprintf(g.b, "func (p *parser) %s(yylex *Tokenizer) (%s, bool) {\n", d.name, typ) + fmt.Fprintf(g.b, " var ret %s\n", typ) + var emptyRule string + firstRule := true + for _, r := range d.rules { + if strings.Contains(r.name, "/*empty*/") { + continue + } + // preprocess body + bb := strings.Builder{} + var usedVars int64 + for _, line := range r.body { + line, vars, err := normalizeBodyLine(line) + if err != nil { + return err + } + usedVars |= vars + fmt.Fprintf(&bb, " %s\n", line) + } + fmt.Fprintf(&bb, " return ret, true\n") + parts := strings.Fields(r.name) + if len(parts) == 0 { + emptyRule = bb.String() + continue + } + + var okDefined bool for j, p := range parts { var cmp string if p == "openb" { cmp = "'('" } else if p == "closeb" { cmp = "')'" + } else if p == "}" { + cmp = "'}'" + } else if p == "{" { + cmp = "'{'" } else if _, ok := g.funcExprs[p]; ok { } else { cmp = p } if j == 0 { - if i == 0 { + if firstRule { fmt.Fprintf(g.b, " if ") + firstRule = false } else { - fmt.Fprintf(g.b, "} else if ") + fmt.Fprintf(g.b, " } else if ") } - if cmp != "" { - fmt.Fprintf(g.b, "id == %s {\n", cmp) + if len(parts) == 1 && len(r.body) == 0 { + if cmp != "" { + fmt.Fprintf(g.b, "id, tok := p.peek(); id == %s {\n", cmp) + fmt.Fprintf(g.b, " ret = tok\n") + } else { + fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) + } + } else if cmp != "" { + fmt.Fprintf(g.b, "id, _ := p.peek(); id == %s {\n", cmp) fmt.Fprintf(g.b, " // %s\n", r.name) - fmt.Fprintf(g.b, " var1, _ := p.next()\n") + if setIncludes(usedVars, 1) { + fmt.Fprintf(g.b, " var1, _ := p.next()\n") + } else { + fmt.Fprintf(g.b, " p.next()\n") + } } else { - fmt.Fprintf(g.b, "var1, ok := p.%s(); ok {\n", p) + if setIncludes(usedVars, 1) { + fmt.Fprintf(g.b, "var1, ok := p.%s(yylex); ok {\n", p) + } else { + fmt.Fprintf(g.b, "_, ok := p.%s(yylex); ok {\n", p) + } fmt.Fprintf(g.b, " // %s\n", r.name) } continue @@ -130,18 +194,77 @@ func (g *recursiveGen) genFunc(d *def) error { fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp) fmt.Fprintf(g.b, " }\n") } else if _, ok := g.funcExprs[p]; ok { - fmt.Fprintf(g.b, " var%d, ok := p.%s()\n", j+1, p) + if setIncludes(usedVars, j+1) { + fmt.Fprintf(g.b, " var%d, ok := p.%s(yylex)\n", j+1, p) + okDefined = true + } else if okDefined { + fmt.Fprintf(g.b, " _, ok = p.%s(yylex)\n", p) + } else { + fmt.Fprintf(g.b, " _, ok := p.%s(yylex)\n", p) + okDefined = true + } fmt.Fprintf(g.b, " if !ok {\n") fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok)'\")\n", p, strings.Join(parts[:j], " "), p) fmt.Fprintf(g.b, " }\n") } } //success, return - for _, r := range r.body { - fmt.Fprintf(g.b, " %s\n", r) - } - fmt.Fprintf(g.b, " }\n") + fmt.Fprint(g.b, bb.String()) + } + if emptyRule != "" && len(d.rules) == 1 { + fmt.Fprint(g.b, emptyRule) + fmt.Fprintf(g.b, "}\n\n") + + return nil + } + + fmt.Fprintf(g.b, " }\n") + + if emptyRule != "" { + fmt.Fprint(g.b, emptyRule) + fmt.Fprintf(g.b, " return ret, true\n}\n\n") + } else { + fmt.Fprintf(g.b, " return nil, false\n}\n\n") } - fmt.Fprintf(g.b, "\n return nil, false\n}\n") return nil } + +var variableRe = regexp.MustCompile("\\$([1-6]+[0-9]*|[1-9])") + +func normalizeBodyLine(r string) (string, int64, error) { + r = strings.ReplaceAll(r, "$$ =", "ret =") + r = strings.ReplaceAll(r, "return 1", "return nil, false") + + var variables int64 + r = strings.ReplaceAll(r, "$$", "ret") + match := variableRe.FindAllStringSubmatchIndex(r, 1) + for len(match) > 0 { + m := match[0] + start, end := m[2], m[3] + _int64, err := strconv.ParseInt(r[start:end], 10, 64) + if err != nil { + return "", 0, fmt.Errorf("failed to parse variable string: %s", r[start:end]) + } + if _int64 >= 64 { + return "", 0, fmt.Errorf("variable reference too big: %d", _int64) + } + variables |= (1 << _int64) + r = r[:m[0]] + "var" + r[m[0]+1:] + match = variableRe.FindAllStringSubmatchIndex(r, 1) + } + + //r = strings.ReplaceAll(r, "$1", "var1") + //r = strings.ReplaceAll(r, "$2", "var2") + //r = strings.ReplaceAll(r, "$3", "var3") + //r = strings.ReplaceAll(r, "$4", "var4") + //r = strings.ReplaceAll(r, "$5", "var5") + //r = strings.ReplaceAll(r, "$6", "var6") + //r = strings.ReplaceAll(r, "$7", "var7") + //r = strings.ReplaceAll(r, "$8", "var8") + //r = strings.ReplaceAll(r, "$9", "var9") + return r, variables, nil +} + +func setIncludes(set int64, i int) bool { + return set&(1< 0 +} diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 516298e7297..1c9d0ceb2f7 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -98,6 +98,8 @@ func split(infile io.Reader) (*yaccFileContents, error) { } case "%%": continue + case "{}": + continue } if acc { @@ -120,6 +122,8 @@ func split(infile io.Reader) (*yaccFileContents, error) { } else if strings.HasPrefix(line, "%right") { } else if strings.HasPrefix(line, "%nonassoc") { + } else if strings.HasPrefix(line, "//") { + continue } else if strings.HasPrefix(line, "%start") { yc.start = strings.Split(line, " ")[1] } else if strings.HasPrefix(line, "|") && r != nil { @@ -142,6 +146,13 @@ func split(infile io.Reader) (*yaccFileContents, error) { r.body = append(r.body, line) } else if d != nil { r = new(rule) + if strings.HasSuffix(line, "{}") { + line = line[:len(line)-2] + r.name = parseRuleName(line) + d.rules = append(d.rules, r) + r = nil + continue + } r.name = parseRuleName(line) } } diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 81c6779cda1..3ce63e06817 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -78,6 +78,10 @@ load_statement: $$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13} } +from_or_using: + FROM {} +| USING {} + select_statement: with_select order_by_opt limit_opt lock_opt into_opt { @@ -119,7 +123,7 @@ func TestGen(t *testing.T) { require.NoError(t, err) err = g.gen() require.NoError(t, err) - outfile, err := os.OpenFile("sql.gen.go", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) + outfile, err := os.OpenFile("../../sql.gen.go", os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644) require.NoError(t, err) _, err = io.Copy(outfile, strings.NewReader(g.b.String())) require.NoError(t, err) @@ -142,9 +146,9 @@ func TestSplit(t *testing.T) { {name: "ddl", typ: "*DDL"}, }, yaccTypes: []yaccType{ - {name: "valTuple", typ: "row_tuple"}, - {name: "valTuple", typ: "tuple_or_empty"}, - {name: "expr", typ: "tuple_expression"}, + {name: "row_tuple", typ: "valTuple"}, + {name: "tuple_or_empty", typ: "valTuple"}, + {name: "tuple_expression", typ: "expr"}, }, tokens: nil, start: "any_command", @@ -216,6 +220,19 @@ func TestSplit(t *testing.T) { }, }, }, + { + name: "from_or_using", + rules: []*rule{ + { + name: "FROM", + start: false, + }, + { + name: "USING", + start: false, + }, + }, + }, { name: "select_statement", rules: []*rule{ diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 1f9c2071bec..149692519a8 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -464,8 +464,8 @@ func yySpecialCommentMode(yylex interface{}) bool { %type alter_table_statement_list %type analyze_statement analyze_opt show_statement use_statement prepare_statement execute_statement deallocate_statement %type describe_statement explain_statement explainable_statement -%type begin_statement commit_statement rollback_statement start_transaction_statement load_statement -%type work_opt no_opt chain_opt release_opt index_name_opt no_first_last +%type begin_statement commit_statement rollback_statement start_transaction_statement load_statement any_command +%type work_opt no_opt chain_opt release_opt index_name_opt no_first_last from_or_using fetch_next_from_opt %type comment_opt comment_list %type distinct_opt union_op intersect_op except_op insert_or_replace %type match_option format_opt @@ -2577,7 +2577,6 @@ fetch_next_from_opt: {} | FROM | NEXT FROM - {} fetch_variable_list: ID @@ -7503,10 +7502,8 @@ value_expression: | function_call_window | function_call_aggregate_with_window -/* - Regular function calls without special token or syntax, guaranteed to not - introduce side effects due to being a simple identifier -*/ +// Regular function calls without special token or syntax, guaranteed to not +// introduce side effects due to being a simple identifier function_call_generic: sql_id openb distinct_opt argument_expression_list_opt closeb { From f3d6e0f91ab22f1997a77f7be26c291b49c09157 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Thu, 19 Sep 2024 11:54:56 -0700 Subject: [PATCH 05/14] clean gen --- go/vt/sqlparser/gen/rd/generator.go | 34 ++++++++++++++++++++++------ go/vt/sqlparser/gen/rd/split.go | 7 ++++++ go/vt/sqlparser/gen/rd/split_test.go | 5 ++++ go/vt/sqlparser/sql.y | 16 ++++++------- 4 files changed, 47 insertions(+), 15 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 4436214354f..6e15c4d9370 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -122,6 +122,7 @@ func (g *recursiveGen) genFunc(d *def) error { if strings.Contains(r.name, "/*empty*/") { continue } + // preprocess body bb := strings.Builder{} var usedVars int64 @@ -143,6 +144,10 @@ func (g *recursiveGen) genFunc(d *def) error { var okDefined bool for j, p := range parts { + //if strings.Contains(p, "%prec") { + // continue + //} + var cmp string if p == "openb" { cmp = "'('" @@ -165,8 +170,8 @@ func (g *recursiveGen) genFunc(d *def) error { } if len(parts) == 1 && len(r.body) == 0 { if cmp != "" { - fmt.Fprintf(g.b, "id, tok := p.peek(); id == %s {\n", cmp) - fmt.Fprintf(g.b, " ret = tok\n") + fmt.Fprintf(g.b, "id, tok1 := p.peek(); id == %s {\n", cmp) + fmt.Fprintf(g.b, " ret = tok1\n") } else { fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) } @@ -189,9 +194,9 @@ func (g *recursiveGen) genFunc(d *def) error { continue } if cmp != "" { - fmt.Fprintf(g.b, " var%d, tok := p.next()\n", j+1) + fmt.Fprintf(g.b, " var%d, tok%d := p.next()\n", j+1, j+1) fmt.Fprintf(g.b, " if var%d != %s {\n", j+1, cmp) - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp) + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok%d) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp, j+1) fmt.Fprintf(g.b, " }\n") } else if _, ok := g.funcExprs[p]; ok { if setIncludes(usedVars, j+1) { @@ -204,7 +209,7 @@ func (g *recursiveGen) genFunc(d *def) error { okDefined = true } fmt.Fprintf(g.b, " if !ok {\n") - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok)'\")\n", p, strings.Join(parts[:j], " "), p) + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok%d)'\")\n", p, strings.Join(parts[:j], " "), p, j+1) fmt.Fprintf(g.b, " }\n") } } @@ -224,7 +229,19 @@ func (g *recursiveGen) genFunc(d *def) error { fmt.Fprint(g.b, emptyRule) fmt.Fprintf(g.b, " return ret, true\n}\n\n") } else { - fmt.Fprintf(g.b, " return nil, false\n}\n\n") + fmt.Fprintf(g.b, " return ret, false\n}\n\n") + + //defRet := "nil" + //if typ == "string" { + // defRet = "\"\"" + //} else if typ == "int" { + // defRet = "0" + //} else if strings.HasPrefix(typ, "*") { + //} else if typ == "Expr" { + //} else { + // defRet = typ + "{}" + //} + //fmt.Fprintf(g.b, " return %s, false\n}\n\n", defRet) } return nil } @@ -233,7 +250,7 @@ var variableRe = regexp.MustCompile("\\$([1-6]+[0-9]*|[1-9])") func normalizeBodyLine(r string) (string, int64, error) { r = strings.ReplaceAll(r, "$$ =", "ret =") - r = strings.ReplaceAll(r, "return 1", "return nil, false") + r = strings.ReplaceAll(r, "return 1", "return ret, false") var variables int64 r = strings.ReplaceAll(r, "$$", "ret") @@ -253,6 +270,9 @@ func normalizeBodyLine(r string) (string, int64, error) { match = variableRe.FindAllStringSubmatchIndex(r, 1) } + r = strings.ReplaceAll(r, "NewIntVal(var", "NewIntVal(tok") + r = strings.ReplaceAll(r, "NewStringVal(var", "NewStringVal(tok") + //r = strings.ReplaceAll(r, "$1", "var1") //r = strings.ReplaceAll(r, "$2", "var2") //r = strings.ReplaceAll(r, "$3", "var3") diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 1c9d0ceb2f7..ca953e1cb70 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -61,6 +61,9 @@ func split(infile io.Reader) (*yaccFileContents, error) { if len(line) == 0 { continue } + + line = strings.ReplaceAll(line, "%prec", "") + switch line { case "{": if r == nil { @@ -132,6 +135,10 @@ func split(infile io.Reader) (*yaccFileContents, error) { } if line[len(line)-1] == ':' { + if r != nil { + d.rules = append(d.rules, r) + r = nil + } if d != nil { yc.defs = append(yc.defs, d) } diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 3ce63e06817..8e5729ae1e3 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -81,6 +81,7 @@ load_statement: from_or_using: FROM {} | USING {} +| OTHER select_statement: with_select order_by_opt limit_opt lock_opt into_opt @@ -231,6 +232,10 @@ func TestSplit(t *testing.T) { name: "USING", start: false, }, + { + name: "OTHER", + start: false, + }, }, }, { diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 149692519a8..af5316aaf2d 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -1345,7 +1345,7 @@ srs_attribute: } opt_with_check_option: - /* EMPTY */ + /*empty*/ { $$ = ViewCheckOptionUnspecified } @@ -4001,7 +4001,7 @@ index_option: } equal_opt: - /* empty */ + /*empty*/ { $$ = "" } @@ -5938,7 +5938,7 @@ LIKE value_expression like_escape_opt } full_opt: - /* empty */ + /*empty*/ { $$ = false } @@ -5958,7 +5958,7 @@ columns_or_fields: } from_database_opt: - /* empty */ + /*empty*/ { $$ = "" } @@ -5972,7 +5972,7 @@ from_database_opt: } like_or_where_opt: - /* empty */ + /*empty*/ { $$ = nil } @@ -5990,7 +5990,7 @@ like_or_where_opt: } show_session_or_global: - /* empty */ + /*empty*/ { $$ = "" } @@ -7174,7 +7174,7 @@ expression: } default_opt: - /* empty */ + /*empty*/ { $$ = "" } @@ -7839,7 +7839,7 @@ function_call_on_update: // Optional parens for certain keyword functions that don't require them. func_parens_opt: - /* empty */ + /*empty*/ | openb closeb // Optional datetime precision for certain functions. From c591cab7ef897d1c008b2c07c9705f1f410a2365 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Thu, 19 Sep 2024 13:41:56 -0700 Subject: [PATCH 06/14] more bugs, tests --- go/vt/sqlparser/gen/rd/generator.go | 2 +- go/vt/sqlparser/gen/rd/split.go | 4 + go/vt/sqlparser/rdparser.go | 2 +- go/vt/sqlparser/rdparser_test.go | 44 +++++++++++ go/vt/sqlparser/sql.y | 114 +++++++++++++++------------- 5 files changed, 111 insertions(+), 55 deletions(-) create mode 100644 go/vt/sqlparser/rdparser_test.go diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 6e15c4d9370..9c7a8b59b72 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -271,7 +271,7 @@ func normalizeBodyLine(r string) (string, int64, error) { } r = strings.ReplaceAll(r, "NewIntVal(var", "NewIntVal(tok") - r = strings.ReplaceAll(r, "NewStringVal(var", "NewStringVal(tok") + r = strings.ReplaceAll(r, "NewStrVal(var", "NewStrVal(tok") //r = strings.ReplaceAll(r, "$1", "var1") //r = strings.ReplaceAll(r, "$2", "var2") diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index ca953e1cb70..558d10214e3 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -83,6 +83,8 @@ func split(infile io.Reader) (*yaccFileContents, error) { case "%union {": acc = true continue + case "},", "})": + nesting-- case "}": if nesting > 0 { nesting-- @@ -132,6 +134,8 @@ func split(infile io.Reader) (*yaccFileContents, error) { } else if strings.HasPrefix(line, "|") && r != nil { d.rules = append(d.rules, r) r = nil + } else if strings.HasPrefix(line, "} else") && r != nil { + nesting-- } if line[len(line)-1] == ':' { diff --git a/go/vt/sqlparser/rdparser.go b/go/vt/sqlparser/rdparser.go index 2dc82c1f31e..4910b52e021 100644 --- a/go/vt/sqlparser/rdparser.go +++ b/go/vt/sqlparser/rdparser.go @@ -32,7 +32,7 @@ func (p *parser) parse(ctx context.Context, s string, options ParserOptions) (re p.tok = NewStringTokenizerForAnsiQuotes(s) } - if prePlan, ok := p.statement(ctx); ok { + if prePlan, ok := p.any_command(p.tok); ok { return prePlan, nil } diff --git a/go/vt/sqlparser/rdparser_test.go b/go/vt/sqlparser/rdparser_test.go new file mode 100644 index 00000000000..7c6088a83e6 --- /dev/null +++ b/go/vt/sqlparser/rdparser_test.go @@ -0,0 +1,44 @@ +package sqlparser + +import ( + "github.com/stretchr/testify/require" + "testing" +) + +func TestParser(t *testing.T) { + tests := []struct { + q string + exp Statement + ok bool + }{ + { + q: "insert into xy values (0,'0', .0), (1,'1', 1.0)", + ok: true, + }, + { + q: "insert into xy (x,y,z) values (0,'0', .0), (1,'1', 1.0)", + ok: true, + }, + { + q: "insert into db.xy values (0,'0', .0), (1,'1', 1.0)", + ok: true, + }, + { + q: "select * from xy where x = 1", + ok: true, + }, + { + q: "select id from sbtest1 where id = 1000", + ok: true, + }, + } + for _, tt := range tests { + t.Run(tt.q, func(t *testing.T) { + p := new(parser) + p.tok = NewStringTokenizer(tt.q) + res, ok := p.anyCommand(p.tok) + require.Equal(t, tt.ok, ok) + require.Equal(t, tt.exp, res) + }) + } +} diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index af5316aaf2d..747542482a4 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -3832,25 +3832,41 @@ flush_option: } flush_tables_read_lock_opt: - {$$ = false} + { + $$ = false + } | WITH READ LOCK - {$$ = true} + { + $$ = true + } relay_logs_attribute: - { $$ = "" } + { + $$ = "" + } | FOR CHANNEL STRING - { $$ = string($3) } + { + $$ = string($3) + } flush_type: NO_WRITE_TO_BINLOG - { $$ = string($1) } + { + $$ = string($1) + } | LOCAL - { $$ = string($1) } + { + $$ = string($1) + } flush_type_opt: - { $$ = "" } + { + $$ = "" + } | flush_type - { $$ = $1 } + { + $$ = $1 + } replication_statement: CHANGE REPLICATION SOURCE TO replication_option_list @@ -3875,9 +3891,13 @@ replication_statement: } all_opt: - { $$ = false } + { + $$ = false + } | ALL - { $$ = true } + { + $$ = true + } replication_option_list: @@ -3970,7 +3990,8 @@ index_option_list: } index_option: - USING any_identifier // TODO: should be restricted +// TODO: should be restricted + USING any_identifier { $$ = &IndexOption{Name: string($1), Using: string($2)} } @@ -5754,11 +5775,12 @@ deallocate_statement: } show_statement: - SHOW BINARY ID /* SHOW BINARY LOGS */ +// SHOW BINARY LOGS + SHOW BINARY ID { $$ = &Show{Type: string($2) + " " + string($3)} } -/* SHOW CHARACTER SET and SHOW CHARSET are equivalent */ +// SHOW CHARACTER SET and SHOW CHARSET are equivalent | SHOW CHARACTER SET like_or_where_opt { $$ = &Show{Type: CharsetStr, Filter: $4} @@ -7514,10 +7536,8 @@ function_call_generic: $$ = &FuncExpr{Qualifier: $1, Name: $3, Exprs: $5} } -/* - Special aggregate function calls that can't be treated like a normal function call, because they have an optional - OVER clause (not legal on any other non-window, non-aggregate function) - */ +// Special aggregate function calls that can't be treated like a normal function call, because they have an optional +// OVER clause (not legal on any other non-window, non-aggregate function) function_call_aggregate_with_window: MAX openb distinct_opt argument_expression_list closeb over_opt { @@ -7588,9 +7608,7 @@ function_call_aggregate_with_window: $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3, Over: $5} } -/* - Function calls with an OVER expression, only valid for certain aggregate and window functions -*/ +// Function calls with an OVER expression, only valid for certain aggregate and window functions function_call_window: CUME_DIST openb closeb over { @@ -7637,11 +7655,9 @@ function_call_window: $$ = &FuncExpr{Name: NewColIdent(string($1)), Over: $4} } -/* - Function calls using reserved keywords, with dedicated grammar rules - as a result - TODO: some of these change the case or even the name of the function expression. Should be preserved. -*/ + // Function calls using reserved keywords, with dedicated grammar rules + // as a result + // TODO: some of these change the case or even the name of the function expression. Should be preserved. function_call_keyword: LEFT openb argument_expression_list closeb { @@ -7761,10 +7777,8 @@ function_call_keyword: $$ = &FuncExpr{Name: NewColIdent(string($1)), Exprs: $3} } -/* - Function calls using non reserved keywords but with special syntax forms. - Dedicated grammar rules are needed because of the special syntax -*/ +// Function calls using non reserved keywords but with special syntax forms. +// Dedicated grammar rules are needed because of the special syntax function_call_nonkeyword: // functions that do not support fractional second precision (fsp) CURRENT_DATE func_parens_opt @@ -7854,10 +7868,8 @@ func_datetime_prec_opt: $$ = NewIntVal($2) } -/* - Function calls using non reserved keywords with *normal* syntax forms. Because - the names are non-reserved, they need a dedicated rule so as not to conflict -*/ +// Function calls using non reserved keywords with *normal* syntax forms. Because +// the names are non-reserved, they need a dedicated rule so as not to conflict function_call_conflict: IF openb argument_expression_list closeb { @@ -9052,19 +9064,17 @@ kill_statement: $$ = &Kill{Connection: true, ConnID: NewIntVal($3)} } -/* - Reserved keywords are keywords that MUST be backtick quoted to be used as an identifier. They cannot - parse correctly as an identifier otherwise. These are not all necessarily reserved keywords in MySQL, but some are. - These are reserved because they may cause parse conflicts in our grammar. - - TODO: Would be helpful to annotate which are NOT reserved in MySQL. Each of those non-reserved keywords that - we require to be backtick quoted is a potential customer issue since there's a compatibility issue with MySQL. - - If you want to move one that is not reserved in MySQL (i.e. ESCAPE) to the - non_reserved_keywords, you'll need to deal with any conflicts. - - Sorted alphabetically -*/ +// Reserved keywords are keywords that MUST be backtick quoted to be used as an identifier. They cannot +// parse correctly as an identifier otherwise. These are not all necessarily reserved keywords in MySQL, but some are. +// These are reserved because they may cause parse conflicts in our grammar. +// +// TODO: Would be helpful to annotate which are NOT reserved in MySQL. Each of those non-reserved keywords that +// we require to be backtick quoted is a potential customer issue since there's a compatibility issue with MySQL. +// +// If you want to move one that is not reserved in MySQL (i.e. ESCAPE) to the +// non_reserved_keywords, you'll need to deal with any conflicts. +// +// Sorted alphabetically reserved_keyword: ACCESSIBLE | ADD @@ -9615,13 +9625,11 @@ qualified_column_name_safe_reserved_keyword: | YEAR_MONTH | ZEROFILL -/* - These are non-reserved keywords for Vitess – they don't cause conflicts in the grammar when used as identifiers. - They can be safely used as unquoted identifiers in queries. Some may be reserved in MySQL, so we backtick quote - them when we rewrite the query, to prevent any issues. - - Sorted alphabetically -*/ +// These are non-reserved keywords for Vitess – they don't cause conflicts in the grammar when used as identifiers. +// They can be safely used as unquoted identifiers in queries. Some may be reserved in MySQL, so we backtick quote +// them when we rewrite the query, to prevent any issues. +// +// Sorted alphabetically non_reserved_keyword: ACTION | ACTIVE From f8e78c99c762251cc7f52be9e67038b5c61d472b Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Fri, 20 Sep 2024 20:33:51 -0700 Subject: [PATCH 07/14] progress --- go/vt/sqlparser/gen/rd/generator.go | 239 ++++++++++++++++----------- go/vt/sqlparser/gen/rd/split.go | 43 ++++- go/vt/sqlparser/gen/rd/split_test.go | 77 +++++++++ go/vt/sqlparser/rdparser.go | 4 +- go/vt/sqlparser/rdparser_test.go | 2 +- go/vt/sqlparser/sql.y | 3 +- 6 files changed, 260 insertions(+), 108 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 9c7a8b59b72..8a4424eeeac 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -55,6 +55,11 @@ func (g *recursiveGen) init() (err error) { } g.funcExprs[d.name] = goTyp } + for _, d := range g.yacc.defs { + if _, ok := g.funcExprs[d.name]; !ok { + g.funcExprs[d.name] = "[]byte" + } + } return nil } @@ -106,12 +111,13 @@ func (g *recursiveGen) genFunc(d *def) error { if !ok { log.Printf("function type not found: %s\n", d.name) typ = "[]byte" + g.funcExprs[d.name] = "[]byte" } //switch d.name { //case "lexer_old_position", "lexer_position", "special_comment_mode": // return nil //} - if d.name == "view_name_list" { + if d.name == "func_parens_opt" { print() } fmt.Fprintf(g.b, "func (p *parser) %s(yylex *Tokenizer) (%s, bool) {\n", d.name, typ) @@ -119,102 +125,10 @@ func (g *recursiveGen) genFunc(d *def) error { var emptyRule string firstRule := true for _, r := range d.rules { - if strings.Contains(r.name, "/*empty*/") { - continue - } - - // preprocess body - bb := strings.Builder{} - var usedVars int64 - for _, line := range r.body { - line, vars, err := normalizeBodyLine(line) - if err != nil { - return err - } - usedVars |= vars - fmt.Fprintf(&bb, " %s\n", line) - } - fmt.Fprintf(&bb, " return ret, true\n") - - parts := strings.Fields(r.name) - if len(parts) == 0 { - emptyRule = bb.String() - continue - } - - var okDefined bool - for j, p := range parts { - //if strings.Contains(p, "%prec") { - // continue - //} - - var cmp string - if p == "openb" { - cmp = "'('" - } else if p == "closeb" { - cmp = "')'" - } else if p == "}" { - cmp = "'}'" - } else if p == "{" { - cmp = "'{'" - } else if _, ok := g.funcExprs[p]; ok { - } else { - cmp = p - } - if j == 0 { - if firstRule { - fmt.Fprintf(g.b, " if ") - firstRule = false - } else { - fmt.Fprintf(g.b, " } else if ") - } - if len(parts) == 1 && len(r.body) == 0 { - if cmp != "" { - fmt.Fprintf(g.b, "id, tok1 := p.peek(); id == %s {\n", cmp) - fmt.Fprintf(g.b, " ret = tok1\n") - } else { - fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) - } - } else if cmp != "" { - fmt.Fprintf(g.b, "id, _ := p.peek(); id == %s {\n", cmp) - fmt.Fprintf(g.b, " // %s\n", r.name) - if setIncludes(usedVars, 1) { - fmt.Fprintf(g.b, " var1, _ := p.next()\n") - } else { - fmt.Fprintf(g.b, " p.next()\n") - } - } else { - if setIncludes(usedVars, 1) { - fmt.Fprintf(g.b, "var1, ok := p.%s(yylex); ok {\n", p) - } else { - fmt.Fprintf(g.b, "_, ok := p.%s(yylex); ok {\n", p) - } - fmt.Fprintf(g.b, " // %s\n", r.name) - } - continue - } - if cmp != "" { - fmt.Fprintf(g.b, " var%d, tok%d := p.next()\n", j+1, j+1) - fmt.Fprintf(g.b, " if var%d != %s {\n", j+1, cmp) - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(tok%d) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp, j+1) - fmt.Fprintf(g.b, " }\n") - } else if _, ok := g.funcExprs[p]; ok { - if setIncludes(usedVars, j+1) { - fmt.Fprintf(g.b, " var%d, ok := p.%s(yylex)\n", j+1, p) - okDefined = true - } else if okDefined { - fmt.Fprintf(g.b, " _, ok = p.%s(yylex)\n", p) - } else { - fmt.Fprintf(g.b, " _, ok := p.%s(yylex)\n", p) - okDefined = true - } - fmt.Fprintf(g.b, " if !ok {\n") - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: 'string(tok%d)'\")\n", p, strings.Join(parts[:j], " "), p, j+1) - fmt.Fprintf(g.b, " }\n") - } + emptyRule, err := g.genRule(r, firstRule, emptyRule) + if empty != "" { + emptyRule = empty } - //success, return - fmt.Fprint(g.b, bb.String()) } if emptyRule != "" && len(d.rules) == 1 { fmt.Fprint(g.b, emptyRule) @@ -222,6 +136,13 @@ func (g *recursiveGen) genFunc(d *def) error { return nil } + if len(d.selfRec) > 0 { + fmt.Fprintf(g.b, " if ret == nil {\n") + fmt.Fprintf(g.b, " return ret, false\n") + fmt.Fprintf(g.b, " }\n") + fmt.Fprintf(g.b, " var1 := ret\n") + + } fmt.Fprintf(g.b, " }\n") @@ -246,7 +167,109 @@ func (g *recursiveGen) genFunc(d *def) error { return nil } -var variableRe = regexp.MustCompile("\\$([1-6]+[0-9]*|[1-9])") +func (g *recursiveGen) genRule(r *rule, indent string) error { + if strings.Contains(r.name, "/*empty*/") { + return nil + } + + // preprocess body + bb := strings.Builder{} + var usedVars int64 + for _, line := range r.body { + line, vars, err := normalizeBodyLine(line) + if err != nil { + return err + } + usedVars |= vars + fmt.Fprintf(&bb, " %s%s\n", indent, line) + } + fmt.Fprintf(&bb, " return ret, true\n") + + parts := strings.Fields(r.name) + if len(parts) == 0 { + emptyRule = bb.String() + continue + } + + var okDefined bool + for j, p := range parts { + var cmp string + if p == "openb" { + cmp = "'('" + } else if p == "closeb" { + cmp = "')'" + } else if p == "}" { + cmp = "'}'" + } else if p == "{" { + cmp = "'{'" + } else if _, ok := g.funcExprs[p]; ok { + } else if p == "explain_verb" { + } else { + cmp = p + } + + if j == 0 { + if firstRule { + fmt.Fprintf(g.b, " if ") + firstRule = false + } else { + fmt.Fprintf(g.b, " } else if ") + } + if len(parts) == 1 && len(r.body) == 0 { + if cmp != "" { + fmt.Fprintf(g.b, "id, var1 := p.peek(); id == %s {\n", cmp) + fmt.Fprintf(g.b, " ret = var1\n") + } else { + fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) + } + } else if cmp != "" { + fmt.Fprintf(g.b, "id, _ := p.peek(); id == %s {\n", cmp) + fmt.Fprintf(g.b, " // %s\n", r.name) + if setIncludes(usedVars, 1) { + //if isLit(cmp) { + fmt.Fprintf(g.b, " _, var1 := p.next()\n") + //} else { + // fmt.Fprintf(g.b, " var1, _ := p.next()\n") + //} + } else { + fmt.Fprintf(g.b, " p.next()\n") + } + } else { + if setIncludes(usedVars, 1) { + fmt.Fprintf(g.b, "var1, ok := p.%s(yylex); ok {\n", p) + } else { + fmt.Fprintf(g.b, "_, ok := p.%s(yylex); ok {\n", p) + } + fmt.Fprintf(g.b, " // %s\n", r.name) + } + continue + } + if cmp != "" { + fmt.Fprintf(g.b, " id%d, var%d := p.next()\n", j+1, j+1) + fmt.Fprintf(g.b, " if id%d != %s {\n", j+1, cmp) + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(var%d) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp, j+1) + fmt.Fprintf(g.b, " }\n") + } else if _, ok := g.funcExprs[p]; ok { + fmt.Fprintf(g.b, " _, tok%d := p.peek()\n", j+1) + if setIncludes(usedVars, j+1) { + fmt.Fprintf(g.b, " var%d, ok := p.%s(yylex)\n", j+1, p) + okDefined = true + } else if okDefined { + fmt.Fprintf(g.b, " _, ok = p.%s(yylex)\n", p) + } else { + fmt.Fprintf(g.b, " _, ok := p.%s(yylex)\n", p) + okDefined = true + } + fmt.Fprintf(g.b, " if !ok {\n") + fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\"+string(tok%d)+\"'\")\n", p, strings.Join(parts[:j], " "), p, j+1) + fmt.Fprintf(g.b, " }\n") + } + } + //success, return + fmt.Fprint(g.b, bb.String()) +} + +var variableRe = regexp.MustCompile("(New\\w*\\()*\\$([1-6]+[0-9]*|[1-9])") func normalizeBodyLine(r string) (string, int64, error) { r = strings.ReplaceAll(r, "$$ =", "ret =") @@ -257,7 +280,8 @@ func normalizeBodyLine(r string) (string, int64, error) { match := variableRe.FindAllStringSubmatchIndex(r, 1) for len(match) > 0 { m := match[0] - start, end := m[2], m[3] + start, end := m[4], m[5] + _int64, err := strconv.ParseInt(r[start:end], 10, 64) if err != nil { return "", 0, fmt.Errorf("failed to parse variable string: %s", r[start:end]) @@ -265,13 +289,17 @@ func normalizeBodyLine(r string) (string, int64, error) { if _int64 >= 64 { return "", 0, fmt.Errorf("variable reference too big: %d", _int64) } + r = r[:start-1] + "var" + r[start:] variables |= (1 << _int64) - r = r[:m[0]] + "var" + r[m[0]+1:] match = variableRe.FindAllStringSubmatchIndex(r, 1) } - r = strings.ReplaceAll(r, "NewIntVal(var", "NewIntVal(tok") - r = strings.ReplaceAll(r, "NewStrVal(var", "NewStrVal(tok") + //r = strings.ReplaceAll(r, "NewIntVal(var", "NewIntVal(tok") + //r = strings.ReplaceAll(r, "NewStrVal(var", "NewStrVal(tok") + //r = strings.ReplaceAll(r, "NewValArg(var", "NewValArg(tok") + //r = strings.ReplaceAll(r, "NewListArg(var", "NewListArg(tok") + //r = strings.ReplaceAll(r, "NewBitVal(var", "NewBitVal(tok") + //r = strings.ReplaceAll(r, "NewHexVal(var", "NewHexVal(tok") //r = strings.ReplaceAll(r, "$1", "var1") //r = strings.ReplaceAll(r, "$2", "var2") @@ -288,3 +316,12 @@ func normalizeBodyLine(r string) (string, int64, error) { func setIncludes(set int64, i int) bool { return set&(1< 0 } + +func isLit(p string) bool { + switch p { + case "STRING", "INTEGRAL", "VALUE_ARG", "LIST_ARG", "BIT_LITERAL", "HEX", "FLOAT": + return true + default: + return false + } +} diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 558d10214e3..c3302128693 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -36,8 +36,9 @@ type yaccToken struct { } type def struct { - name string - rules []*rule + name string + rules []*rule + selfRec []*rule } type rule struct { @@ -62,6 +63,10 @@ func split(infile io.Reader) (*yaccFileContents, error) { continue } + if line == "/*empty*/" { + print() + } + line = strings.ReplaceAll(line, "%prec", "") switch line { @@ -107,6 +112,16 @@ func split(infile io.Reader) (*yaccFileContents, error) { continue } + if line[0] == '{' && line[len(line)-1] == '}' { + if r == nil { + r = new(rule) + } + r.body = append(r.body, strings.TrimSpace(line[1:len(line)-1])) + d.rules = append(d.rules, r) + r = nil + continue + } + if acc { if line[len(line)-1] == '{' { nesting++ @@ -138,7 +153,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { nesting-- } - if line[len(line)-1] == ':' { + if line[len(line)-1] == ':' && !strings.HasPrefix(line, "case ") { if r != nil { d.rules = append(d.rules, r) r = nil @@ -167,12 +182,34 @@ func split(infile io.Reader) (*yaccFileContents, error) { r.name = parseRuleName(line) } } + if r != nil { + d.rules = append(d.rules, r) + } if d != nil { + d.segmentLeftRecursion() yc.defs = append(yc.defs, d) } return yc, nil } +func (d *def) segmentLeftRecursion() { + i := 0 + j := len(d.rules) - 1 + for j > 0 && strings.HasPrefix(d.rules[j].name, d.name) { + j-- + } + for i <= j { + if strings.HasPrefix(d.rules[i].name, d.name) { + d.rules[i], d.rules[j] = d.rules[j], d.rules[i] + j-- + } else { + i++ + } + } + d.selfRec = d.rules[i:] + d.rules = d.rules[:i] +} + func parseRuleName(s string) string { s = strings.TrimSpace(s) if s[0] == '|' { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 8e5729ae1e3..2a87619b4e7 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -1,6 +1,7 @@ package rd import ( + "fmt" "github.com/stretchr/testify/require" "io" "os" @@ -105,6 +106,16 @@ select_statement: } } +join_condition: + { $$ = JoinCondition{On: $2} } + ON expression + { $$ = JoinCondition{On: $2} } +| USING '(' column_list ')' + { $$ = JoinCondition{Using: $3} } + +func_parens_opt: + /*empty*/ +| openb closeb ` type emptyWriter struct{} @@ -130,6 +141,39 @@ func TestGen(t *testing.T) { require.NoError(t, err) } +func TestLeftRecursion(t *testing.T) { + y := ` +comment_opt: + { + setAllowComments(yylex, true) + } + comment_list + { + $$ = $2 + setAllowComments(yylex, false) + } + +comment_list: + { + $$ = nil + } +| comment_list COMMENT + { + $$ = append($1, $2) + } +| comment_list ',' COMMENT + { + $$ = append($1, $3) + } +` + inp := strings.NewReader(y) + g := newRecursiveGen(inp, emptyWriter{}) + err := g.init() + require.NoError(t, err) + err = g.gen() + fmt.Println(g.b.String()) +} + func TestSplit(t *testing.T) { inp := strings.NewReader(testY) cmp, err := split(inp) @@ -269,6 +313,39 @@ func TestSplit(t *testing.T) { }, }, }, + { + name: "join_condition", + rules: []*rule{ + { + name: "", + start: false, + body: []string{"$$ = JoinCondition{On: $2}"}, + }, + { + name: "ON expression", + start: false, + body: []string{"$$ = JoinCondition{On: $2}"}, + }, + { + name: "USING '(' column_list ')'", + start: false, + body: []string{"$$ = JoinCondition{Using: $3}"}, + }, + }, + }, + { + name: "func_parens_opt", + rules: []*rule{ + { + name: "/*empty*/", + start: false, + }, + { + name: "openb closeb", + start: false, + }, + }, + }, }, } diff --git a/go/vt/sqlparser/rdparser.go b/go/vt/sqlparser/rdparser.go index 4910b52e021..f168d7d37a2 100644 --- a/go/vt/sqlparser/rdparser.go +++ b/go/vt/sqlparser/rdparser.go @@ -49,11 +49,11 @@ func (p *parser) fail(s string) { func (p *parser) next() (int, []byte) { if p.peekOk { - p.peekOk = false p.curId, p.cur = p.peekId, p._peek } p.curOk = true - p.curId, p.cur = p.tok.Scan() + p.peekOk = true + p.peekId, p._peek = p.tok.Scan() return p.curId, p.cur } diff --git a/go/vt/sqlparser/rdparser_test.go b/go/vt/sqlparser/rdparser_test.go index 7c6088a83e6..ec66d292f36 100644 --- a/go/vt/sqlparser/rdparser_test.go +++ b/go/vt/sqlparser/rdparser_test.go @@ -36,7 +36,7 @@ func TestParser(t *testing.T) { t.Run(tt.q, func(t *testing.T) { p := new(parser) p.tok = NewStringTokenizer(tt.q) - res, ok := p.anyCommand(p.tok) + res, ok := p.any_command(p.tok) require.Equal(t, tt.ok, ok) require.Equal(t, tt.exp, res) }) diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 747542482a4..ee9be60a5a7 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -8581,7 +8581,8 @@ ins_column_list: } ins_column: - reserved_sql_id '.' reserved_sql_id // TODO: This throws away the qualifier, not a huge deal for insert into, but is incorrect +// TODO: This throws away the qualifier, not a huge deal for insert into, but is incorrect + reserved_sql_id '.' reserved_sql_id { $$ = $3 } From 37693266e5ffd2f13df145f53a8d94e2158d63fc Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Tue, 24 Sep 2024 15:54:24 -0700 Subject: [PATCH 08/14] progress --- go/vt/sqlparser/gen/rd/generator.go | 426 +++++++++++++++++++-------- go/vt/sqlparser/gen/rd/split.go | 140 +++++++-- go/vt/sqlparser/gen/rd/split_test.go | 273 +++++++++-------- 3 files changed, 569 insertions(+), 270 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 8a4424eeeac..09db1c0be7e 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -113,162 +113,336 @@ func (g *recursiveGen) genFunc(d *def) error { typ = "[]byte" g.funcExprs[d.name] = "[]byte" } - //switch d.name { - //case "lexer_old_position", "lexer_position", "special_comment_mode": + + fmt.Fprintf(g.b, "func (p *parser) %s(yylex *Tokenizer) (%s, bool) {\n", d.name, typ) + fmt.Fprintf(g.b, " var ret %s\n", typ) + fmt.Fprintf(g.b, " var matched bool\n") + + g.dfsRuleGen(d.rules, 1, true, " ") + + //var emptyRule string + //firstRule := true + // recursive can have empty rule + // recursive structure: + // - leaf rules + // - if leaf rule nil return nil + // - if leaf not nil try to match next characters + + //dfsRuleGen(d.rules, true, " ") + + //if emptyRule != "" && len(d.rules) == 1 { + // fmt.Fprint(g.b, emptyRule) + // fmt.Fprintf(g.b, "}\n\n") + // // return nil //} - if d.name == "func_parens_opt" { - print() + //if len(d.selfRec) > 0 { + // fmt.Fprintf(g.b, " if ret == nil {\n") + // fmt.Fprintf(g.b, " return ret, false\n") + // fmt.Fprintf(g.b, " }\n") + // fmt.Fprintf(g.b, " var1 := ret\n") + // + //} + + //fmt.Fprintf(g.b, " }\n") + // + //if emptyRule != "" { + // fmt.Fprint(g.b, emptyRule) + // fmt.Fprintf(g.b, " return ret, true\n}\n\n") + //} else { + // fmt.Fprintf(g.b, " return ret, false\n}\n\n") + + //defRet := "nil" + //if typ == "string" { + // defRet = "\"\"" + //} else if typ == "int" { + // defRet = "0" + //} else if strings.HasPrefix(typ, "*") { + //} else if typ == "Expr" { + //} else { + // defRet = typ + "{}" + //} + //fmt.Fprintf(g.b, " return %s, false\n}\n\n", defRet) + //} + return nil +} + +func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent string) error { + var nesting int + if r.prefix != "" { + match, err := g.nestMatch(r.prefix, fid, first, r.usedVars, indent) + if err != nil { + return err + } + indent += " " + fid++ + first = true + nesting++ + fmt.Fprintf(g.b, match) } - fmt.Fprintf(g.b, "func (p *parser) %s(yylex *Tokenizer) (%s, bool) {\n", d.name, typ) - fmt.Fprintf(g.b, " var ret %s\n", typ) - var emptyRule string - firstRule := true - for _, r := range d.rules { - emptyRule, err := g.genRule(r, firstRule, emptyRule) - if empty != "" { - emptyRule = empty + // try to match terminal rules, easiest to distinguish + for _, r := range r.term { + // match terminal rule + match, err := g.termRuleMatch(r, fid, first, r.usedVars, indent) + if err != nil { + return err } + first = false + fmt.Fprintf(g.b, match) } - if emptyRule != "" && len(d.rules) == 1 { - fmt.Fprint(g.b, emptyRule) - fmt.Fprintf(g.b, "}\n\n") - return nil + // nested rule clusters + for _, r := range r.pref { + err := g.dfsRuleGen(r, fid, first, indent) + if err != nil { + return err + } } - if len(d.selfRec) > 0 { - fmt.Fprintf(g.b, " if ret == nil {\n") - fmt.Fprintf(g.b, " return ret, false\n") - fmt.Fprintf(g.b, " }\n") - fmt.Fprintf(g.b, " var1 := ret\n") + if r.empty != nil { + // returns before recursive + if first { + // no other rules in block + fmt.Fprintf(g.b, "%sreturn ret, true\n", indent) + } else { + fmt.Fprintf(g.b, "%s} else {\n", indent) + fmt.Fprintf(g.b, "%s return ret, true\n", indent) + fmt.Fprintf(g.b, "%s}\n", indent) + } } - fmt.Fprintf(g.b, " }\n") + // recursive is special + // field match is different, because it's whether we've matched current scope + if r.rec != nil { + // if no match, we don't recurse + fmt.Fprintf(g.b, "%sif !matched {\n", indent) + fmt.Fprintf(g.b, "%s return ret, false\n", indent) + fmt.Fprintf(g.b, "%s}\n", indent) + // otherwise |ret| becomes |var1| for the left recursion + // rule body + fmt.Fprintf(g.b, "%svar1 = ret\n", indent) - if emptyRule != "" { - fmt.Fprint(g.b, emptyRule) - fmt.Fprintf(g.b, " return ret, true\n}\n\n") - } else { - fmt.Fprintf(g.b, " return ret, false\n}\n\n") - - //defRet := "nil" - //if typ == "string" { - // defRet = "\"\"" - //} else if typ == "int" { - // defRet = "0" - //} else if strings.HasPrefix(typ, "*") { - //} else if typ == "Expr" { - //} else { - // defRet = typ + "{}" - //} - //fmt.Fprintf(g.b, " return %s, false\n}\n\n", defRet) + r.rec.prefix = "" + err := g.dfsRuleGen(r, fid, first, indent) + if err != nil { + return err + } } + + for i := 0; i < nesting; i++ { + fmt.Fprintf(g.b, "%s}\n", indent) + indent = indent[2:] + } + fmt.Fprintf(g.b, "%sreturn ret, matched\n", indent) return nil } -func (g *recursiveGen) genRule(r *rule, indent string) error { - if strings.Contains(r.name, "/*empty*/") { - return nil +func (g *recursiveGen) termRuleMatch(r *rule, fid int, first bool, usedVars int64, indent string) (string, error) { + var b strings.Builder + + // nest the first token + match, err := g.nestMatch(r.fields[0], fid, first, r.usedVars, indent) + if err != nil { + return "", err } + fid++ + indent += " " - // preprocess body - bb := strings.Builder{} - var usedVars int64 - for _, line := range r.body { - line, vars, err := normalizeBodyLine(line) + // rest of tokens have to match + var okDefined bool + for i, f := range r.fields[1:] { + match, okDefined, err = g.termMatch(f, r.fields[:i], fid, first, okDefined, r.usedVars, indent) if err != nil { - return err + return "", err } - usedVars |= vars - fmt.Fprintf(&bb, " %s%s\n", indent, line) + fid++ + fmt.Fprintf(&b, match) } - fmt.Fprintf(&bb, " return ret, true\n") + // if all tokens match, set |matched| var + fmt.Fprintf(&b, "%smatched = true\n", indent) + + return b.String(), nil +} - parts := strings.Fields(r.name) - if len(parts) == 0 { - emptyRule = bb.String() - continue +func (g *recursiveGen) nestMatch(f string, fid int, first bool, usedVars int64, indent string) (string, error) { + var b strings.Builder + var cmp string + if f == "openb" { + cmp = "'('" + } else if f == "closeb" { + cmp = "')'" + } else if f == "}" { + cmp = "'}'" + } else if f == "{" { + cmp = "'{'" + } else if _, ok := g.funcExprs[f]; ok { + } else { + cmp = f } - var okDefined bool - for j, p := range parts { - var cmp string - if p == "openb" { - cmp = "'('" - } else if p == "closeb" { - cmp = "')'" - } else if p == "}" { - cmp = "'}'" - } else if p == "{" { - cmp = "'{'" - } else if _, ok := g.funcExprs[p]; ok { - } else if p == "explain_verb" { + if first { + fmt.Fprintf(&b, "%sif ", indent) + } else { + fmt.Fprintf(&b, "%selse if ", indent) + } + + if cmp != "" { + fmt.Fprintf(&b, "%sid, _ := p.peek(); id == %s {\n", indent, cmp) + if setIncludes(usedVars, fid) { + fmt.Fprintf(&b, "%s _, var%d := p.next()\n", indent, fid) } else { - cmp = p + fmt.Fprintf(&b, "%s p.next()\n", indent) } - - if j == 0 { - if firstRule { - fmt.Fprintf(g.b, " if ") - firstRule = false - } else { - fmt.Fprintf(g.b, " } else if ") - } - if len(parts) == 1 && len(r.body) == 0 { - if cmp != "" { - fmt.Fprintf(g.b, "id, var1 := p.peek(); id == %s {\n", cmp) - fmt.Fprintf(g.b, " ret = var1\n") - } else { - fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) - } - } else if cmp != "" { - fmt.Fprintf(g.b, "id, _ := p.peek(); id == %s {\n", cmp) - fmt.Fprintf(g.b, " // %s\n", r.name) - if setIncludes(usedVars, 1) { - //if isLit(cmp) { - fmt.Fprintf(g.b, " _, var1 := p.next()\n") - //} else { - // fmt.Fprintf(g.b, " var1, _ := p.next()\n") - //} - } else { - fmt.Fprintf(g.b, " p.next()\n") - } - } else { - if setIncludes(usedVars, 1) { - fmt.Fprintf(g.b, "var1, ok := p.%s(yylex); ok {\n", p) - } else { - fmt.Fprintf(g.b, "_, ok := p.%s(yylex); ok {\n", p) - } - fmt.Fprintf(g.b, " // %s\n", r.name) - } - continue + } else { + if setIncludes(usedVars, fid) { + fmt.Fprintf(&b, "%svar%d, ok := p.%s(yylex); ok {\n", indent, fid, f) + } else { + fmt.Fprintf(&b, "%s_, ok := p.%s(yylex); ok {\n", indent, f) } - if cmp != "" { - fmt.Fprintf(g.b, " id%d, var%d := p.next()\n", j+1, j+1) - fmt.Fprintf(g.b, " if id%d != %s {\n", j+1, cmp) - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(var%d) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp, j+1) - fmt.Fprintf(g.b, " }\n") - } else if _, ok := g.funcExprs[p]; ok { - fmt.Fprintf(g.b, " _, tok%d := p.peek()\n", j+1) - if setIncludes(usedVars, j+1) { - fmt.Fprintf(g.b, " var%d, ok := p.%s(yylex)\n", j+1, p) - okDefined = true - } else if okDefined { - fmt.Fprintf(g.b, " _, ok = p.%s(yylex)\n", p) - } else { - fmt.Fprintf(g.b, " _, ok := p.%s(yylex)\n", p) - okDefined = true - } - fmt.Fprintf(g.b, " if !ok {\n") - fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\"+string(tok%d)+\"'\")\n", p, strings.Join(parts[:j], " "), p, j+1) - fmt.Fprintf(g.b, " }\n") + } + return b.String(), nil +} + +func (g *recursiveGen) termMatch(f string, priorFields []string, fid int, first, okDefined bool, usedVars int64, indent string) (string, bool, error) { + var b strings.Builder + var cmp string + if f == "openb" { + cmp = "'('" + } else if f == "closeb" { + cmp = "')'" + } else if f == "}" { + cmp = "'}'" + } else if f == "{" { + cmp = "'{'" + } else if _, ok := g.funcExprs[f]; ok { + } else { + cmp = f + } + + if cmp != "" { + fmt.Fprintf(&b, " id%d, var%d := p.next()\n", fid, fid) + fmt.Fprintf(&b, " if id%d != %s {\n", fid, cmp) + fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(var%d) + \"'\")\n", f, strings.Join(priorFields, " "), cmp, fid) + fmt.Fprintf(&b, " }\n") + } else if _, ok := g.funcExprs[f]; ok { + fmt.Fprintf(&b, " _, tok%d := p.peek()\n", fid) + if setIncludes(usedVars, fid) { + fmt.Fprintf(&b, " var%d, ok := p.%s(yylex)\n", fid, f) + okDefined = true + } else if okDefined { + fmt.Fprintf(&b, " _, ok = p.%s(yylex)\n", f) + } else { + fmt.Fprintf(&b, " _, ok := p.%s(yylex)\n", f) + okDefined = true } + fmt.Fprintf(&b, " if !ok&{\n") + fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: '\"+string(tok%d)+\"'\")\n", f, strings.Join(priorFields, " "), f, fid) + fmt.Fprintf(&b, " }\n") } - //success, return - fmt.Fprint(g.b, bb.String()) + return b.String(), okDefined, nil } +//func (g *recursiveGen) genRule(r *rule, indent string) error { +// if strings.Contains(r.name, "/*empty*/") { +// return nil +// } +// +// // preprocess body +// bb := strings.Builder{} +// var usedVars int64 +// for _, line := range r.body { +// line, vars, err := normalizeBodyLine(line) +// if err != nil { +// return err +// } +// usedVars |= vars +// fmt.Fprintf(&bb, " %s%s\n", indent, line) +// } +// fmt.Fprintf(&bb, " return ret, true\n") +// +// parts := strings.Fields(r.name) +// if len(parts) == 0 { +// emptyRule = bb.String() +// continue +// } +// +// var okDefined bool +// for j, p := range parts { +// var cmp string +// if p == "openb" { +// cmp = "'('" +// } else if p == "closeb" { +// cmp = "')'" +// } else if p == "}" { +// cmp = "'}'" +// } else if p == "{" { +// cmp = "'{'" +// } else if _, ok := g.funcExprs[p]; ok { +// } else { +// cmp = p +// } +// +// if j == 0 { +// if firstRule { +// fmt.Fprintf(g.b, " if ") +// firstRule = false +// } else { +// fmt.Fprintf(g.b, " } else if ") +// } +// if len(parts) == 1 && len(r.body) == 0 { +// if cmp != "" { +// fmt.Fprintf(g.b, "id, var1 := p.peek(); id == %s {\n", cmp) +// fmt.Fprintf(g.b, " ret = var1\n") +// } else { +// fmt.Fprintf(g.b, "ret, ok := p.%s(yylex); ok {\n", p) +// } +// } else if cmp != "" { +// fmt.Fprintf(g.b, "id, _ := p.peek(); id == %s {\n", cmp) +// fmt.Fprintf(g.b, " // %s\n", r.name) +// if setIncludes(usedVars, 1) { +// //if isLit(cmp) { +// fmt.Fprintf(g.b, " _, var1 := p.next()\n") +// //} else { +// // fmt.Fprintf(g.b, " var1, _ := p.next()\n") +// //} +// } else { +// fmt.Fprintf(g.b, " p.next()\n") +// } +// } else { +// if setIncludes(usedVars, 1) { +// fmt.Fprintf(g.b, "var1, ok := p.%s(yylex); ok {\n", p) +// } else { +// fmt.Fprintf(g.b, "_, ok := p.%s(yylex); ok {\n", p) +// } +// fmt.Fprintf(g.b, " // %s\n", r.name) +// } +// continue +// } +// if cmp != "" { +// fmt.Fprintf(g.b, " id%d, var%d := p.next()\n", j+1, j+1) +// fmt.Fprintf(g.b, " if id%d != %s {\n", j+1, cmp) +// fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(var%d) + \"'\")\n", p, strings.Join(parts[:j], " "), cmp, j+1) +// fmt.Fprintf(g.b, " }\n") +// } else if _, ok := g.funcExprs[p]; ok { +// fmt.Fprintf(g.b, " _, tok%d := p.peek()\n", j+1) +// if setIncludes(usedVars, j+1) { +// fmt.Fprintf(g.b, " var%d, ok := p.%s(yylex)\n", j+1, p) +// okDefined = true +// } else if okDefined { +// fmt.Fprintf(g.b, " _, ok = p.%s(yylex)\n", p) +// } else { +// fmt.Fprintf(g.b, " _, ok := p.%s(yylex)\n", p) +// okDefined = true +// } +// fmt.Fprintf(g.b, " if !ok {\n") +// fmt.Fprintf(g.b, " p.fail(\"expected: '%s: %s <%s>', found: '\"+string(tok%d)+\"'\")\n", p, strings.Join(parts[:j], " "), p, j+1) +// fmt.Fprintf(g.b, " }\n") +// } +// } +// //success, return +// fmt.Fprint(g.b, bb.String()) +//} + var variableRe = regexp.MustCompile("(New\\w*\\()*\\$([1-6]+[0-9]*|[1-9])") func normalizeBodyLine(r string) (string, int64, error) { diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index c3302128693..9faa4ee8aeb 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -4,6 +4,7 @@ import ( "bufio" "fmt" "io" + "sort" "strings" ) @@ -36,15 +37,31 @@ type yaccToken struct { } type def struct { - name string - rules []*rule - selfRec []*rule + name string + rules *rulePrefix +} + +func newDef() *def { + d := new(def) + d.rules = new(rulePrefix) + return d } type rule struct { - name string - start bool - body []string + name string + fields []string + start bool + body []string + usedVars int64 +} + +type rulePrefix struct { + prefix string + term []*rule + pref []*rulePrefix + rec *rulePrefix + empty *rule + usedVars int64 } func split(infile io.Reader) (*yaccFileContents, error) { @@ -94,7 +111,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { if nesting > 0 { nesting-- } else if d != nil { - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) r = nil continue } else { @@ -117,7 +134,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { r = new(rule) } r.body = append(r.body, strings.TrimSpace(line[1:len(line)-1])) - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) r = nil continue } @@ -147,7 +164,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { } else if strings.HasPrefix(line, "%start") { yc.start = strings.Split(line, " ")[1] } else if strings.HasPrefix(line, "|") && r != nil { - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) r = nil } else if strings.HasPrefix(line, "} else") && r != nil { nesting-- @@ -155,13 +172,13 @@ func split(infile io.Reader) (*yaccFileContents, error) { if line[len(line)-1] == ':' && !strings.HasPrefix(line, "case ") { if r != nil { - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) r = nil } if d != nil { yc.defs = append(yc.defs, d) } - d = new(def) + d = newDef() d.name = line[:len(line)-1] continue } @@ -175,7 +192,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { if strings.HasSuffix(line, "{}") { line = line[:len(line)-2] r.name = parseRuleName(line) - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) r = nil continue } @@ -183,31 +200,102 @@ func split(infile io.Reader) (*yaccFileContents, error) { } } if r != nil { - d.rules = append(d.rules, r) + d.rules.term = append(d.rules.term, r) } if d != nil { - d.segmentLeftRecursion() + if err := d.finalize(); err != nil { + return nil, err + } yc.defs = append(yc.defs, d) } return yc, nil } -func (d *def) segmentLeftRecursion() { - i := 0 - j := len(d.rules) - 1 - for j > 0 && strings.HasPrefix(d.rules[j].name, d.name) { - j-- +func (d *def) finalize() error { + sort.Slice(d.rules.term, func(i, j int) bool { + return d.rules.term[i].name < d.rules.term[j].name + }) + for _, r := range d.rules.term { + if err := r.calcUsed(); err != nil { + return err + } + r.fields = strings.Fields(r.name) + } + d.rules.partition(d.name) + return nil +} + +func (r *rule) calcUsed() error { + for i, b := range r.body { + newB, used, err := normalizeBodyLine(b) + if err != nil { + return err + } + r.usedVars |= used + r.body[i] = newB + } + return nil +} + +func (d *rulePrefix) calcUsed() { + for _, t := range d.term { + d.usedVars |= t.usedVars } - for i <= j { - if strings.HasPrefix(d.rules[i].name, d.name) { - d.rules[i], d.rules[j] = d.rules[j], d.rules[i] - j-- +} + +func (d *rulePrefix) partition(name string) { + d.calcUsed() + j := 0 + for i := 0; i < len(d.term); i++ { + if len(d.term[i].fields) == 0 { + // empty rule is special, checked last + d.empty = d.term[i] + d.term = append(d.term[:i], d.term[i+1:]...) + i-- + continue + } + if d.term[i].fields[0] != d.term[j].fields[0] { + if i-j > 1 { + // leading field doesn't match, but sequence did + // new partition for the sequence + // recursively partition the subsequence + p := new(rulePrefix) + p.prefix = d.term[j].fields[0] + p.term = make([]*rule, i-j) + copy(p.term, d.term[j:i]) + d.term = append(d.term[:j], d.term[i:]...) + for _, r := range p.term { + r.fields = r.fields[1:] + } + i = j + p.partition(name) + if p.prefix == name { + d.rec = p + } else { + d.pref = append(d.pref, p) + } + } + } + } + if d.term[j-1].fields[0] == d.term[j].fields[0] && len(d.term)-j > 1 { + // leading field doesn't match, but sequence did + // new partition for the sequence + // recursively partition the subsequence + p := new(rulePrefix) + p.prefix = d.term[j].fields[0] + p.term = make([]*rule, len(d.term)-j) + copy(p.term, d.term[j:len(d.term)]) + d.term = append(d.term[:j], d.term[len(d.term):]...) + for _, r := range p.term { + r.fields = r.fields[1:] + } + p.partition(name) + if p.prefix == name { + d.rec = p } else { - i++ + d.pref = append(d.pref, p) } } - d.selfRec = d.rules[i:] - d.rules = d.rules[:i] } func parseRuleName(s string) string { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 2a87619b4e7..06c96eff2ca 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -143,27 +143,40 @@ func TestGen(t *testing.T) { func TestLeftRecursion(t *testing.T) { y := ` -comment_opt: +%union { + expr Expr +} + +%token OR AND NOT +%token value_expr + +value_expr: { - setAllowComments(yylex, true) + $$ = nil } - comment_list +| value_expr OR value_expr { - $$ = $2 - setAllowComments(yylex, false) + $$ = &Or{$1, $3} } - -comment_list: +| value_expr AND value_expr { - $$ = nil + $$ = &And{$1, $3} } -| comment_list COMMENT +| NOT value_expr { - $$ = append($1, $2) + $$ = &Not{$1} } -| comment_list ',' COMMENT +| value_expr NOT AND value_expr { - $$ = append($1, $3) + $$ = &Or{&Not{$1|, &Not{$4}} + } +| value_expr NOT OR value_expr + { + $$ = &And{&Not{$1}, &Not{$4}} + } +| NOT EXISTS value_expr + { + $$ = &Not{&Exists{$1}} } ` inp := strings.NewReader(y) @@ -200,149 +213,173 @@ func TestSplit(t *testing.T) { defs: []*def{ { name: "any_command", - rules: []*rule{ - { - name: "command", - start: true, - body: []string{"setParseTree(yylex, $1)"}, - }, - { - name: "command ';'", - start: true, - body: []string{"setParseTree(yylex, $1)", "statementSeen(yylex)"}, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "command", + start: true, + body: []string{"setParseTree(yylex, $1)"}, + }, + { + name: "command ';'", + start: true, + body: []string{"setParseTree(yylex, $1)", "statementSeen(yylex)"}, + }, }, }, }, { name: "command", - rules: []*rule{ - { - name: "select_statement", - start: true, - body: []string{"$$ = $1"}, - }, - { - name: "values_select_statement", - start: true, - body: []string{"$$ = $1"}, - }, - { - name: "stream_statement", - }, - { - name: "insert_statement", - }, - { - name: "/*empty*/", - start: true, - body: []string{"setParseTree(yylex, nil)"}, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "select_statement", + start: true, + body: []string{"$$ = $1"}, + }, + { + name: "values_select_statement", + start: true, + body: []string{"$$ = $1"}, + }, + { + name: "stream_statement", + }, + { + name: "insert_statement", + }, + { + name: "/*empty*/", + start: true, + body: []string{"setParseTree(yylex, nil)"}, + }, }, }, }, { name: "set_opt", - rules: []*rule{ - { - name: "", - start: true, - body: []string{"$$ = nil"}, - }, - { - name: "SET assignment_list", - start: true, - body: []string{"$$ = $2"}, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "", + start: true, + body: []string{"$$ = nil"}, + }, + { + name: "SET assignment_list", + start: true, + body: []string{"$$ = $2"}, + }, }, }, }, { name: "load_statement", - rules: []*rule{ - { - name: "LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt", - start: true, - body: []string{ - "$$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13}"}, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt", + start: true, + body: []string{ + "$$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13}"}, + }, }, }, }, { name: "from_or_using", - rules: []*rule{ - { - name: "FROM", - start: false, - }, - { - name: "USING", - start: false, - }, - { - name: "OTHER", - start: false, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "FROM", + start: false, + }, + { + name: "USING", + start: false, + }, + { + name: "OTHER", + start: false, + }, }, }, }, { name: "select_statement", - rules: []*rule{ - { - name: "with_select order_by_opt limit_opt lock_opt into_opt", - start: true, - body: []string{ - "$1.SetOrderBy($2)", - "$1.SetLimit($3)", - "$1.SetLock($4)", - "if err := $1.SetInto($5); err != nil {", - "yylex.Error(err.Error())", - "return 1", - "}", - "$$ = $1", + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "with_select order_by_opt limit_opt lock_opt into_opt", + start: true, + body: []string{ + "$1.SetOrderBy($2)", + "$1.SetLimit($3)", + "$1.SetLock($4)", + "if err := $1.SetInto($5); err != nil {", + "yylex.Error(err.Error())", + "return 1", + "}", + "$$ = $1", + }, }, - }, - { - name: "SELECT comment_opt query_opts NEXT num_val for_from table_name", - start: true, - body: []string{ - "$$ = &Select{", - "Comments: Comments($2),", - "QueryOpts: $3,", - "SelectExprs: SelectExprs{Nextval{Expr: $5}},", - "From: TableExprs{&AliasedTableExpr{Expr: $7}},", - "}", + { + name: "SELECT comment_opt query_opts NEXT num_val for_from table_name", + start: true, + body: []string{ + "$$ = &Select{", + "Comments: Comments($2),", + "QueryOpts: $3,", + "SelectExprs: SelectExprs{Nextval{Expr: $5}},", + "From: TableExprs{&AliasedTableExpr{Expr: $7}},", + "}", + }, }, }, }, }, { name: "join_condition", - rules: []*rule{ - { - name: "", - start: false, - body: []string{"$$ = JoinCondition{On: $2}"}, - }, - { - name: "ON expression", - start: false, - body: []string{"$$ = JoinCondition{On: $2}"}, - }, - { - name: "USING '(' column_list ')'", - start: false, - body: []string{"$$ = JoinCondition{Using: $3}"}, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "", + start: false, + body: []string{"$$ = JoinCondition{On: $2}"}, + }, + { + name: "ON expression", + start: false, + body: []string{"$$ = JoinCondition{On: $2}"}, + }, + { + name: "USING '(' column_list ')'", + start: false, + body: []string{"$$ = JoinCondition{Using: $3}"}, + }, }, }, }, { name: "func_parens_opt", - rules: []*rule{ - { - name: "/*empty*/", - start: false, - }, - { - name: "openb closeb", - start: false, + rules: &rulePrefix{ + prefix: "", + term: []*rule{ + { + name: "/*empty*/", + start: false, + }, + { + name: "openb closeb", + start: false, + }, }, }, }, From 3a1086639d8711cff1bc59b28732b4c5cd844912 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Wed, 25 Sep 2024 15:24:05 -0700 Subject: [PATCH 09/14] closer --- go/vt/sqlparser/gen/rd/generator.go | 74 ++++++++++++++++------------ go/vt/sqlparser/gen/rd/split.go | 44 +++++++---------- go/vt/sqlparser/gen/rd/split_test.go | 13 +++-- 3 files changed, 68 insertions(+), 63 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 09db1c0be7e..abbd4a7e430 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -118,7 +118,7 @@ func (g *recursiveGen) genFunc(d *def) error { fmt.Fprintf(g.b, " var ret %s\n", typ) fmt.Fprintf(g.b, " var matched bool\n") - g.dfsRuleGen(d.rules, 1, true, " ") + g.dfsRuleGen(d.name, d.rules, 1, true, " ") //var emptyRule string //firstRule := true @@ -167,14 +167,14 @@ func (g *recursiveGen) genFunc(d *def) error { return nil } -func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent string) error { +func (g *recursiveGen) dfsRuleGen(defName string, r *rulePrefix, fid int, first bool, indent string) error { var nesting int if r.prefix != "" { match, err := g.nestMatch(r.prefix, fid, first, r.usedVars, indent) if err != nil { return err } - indent += " " + indent += " " fid++ first = true nesting++ @@ -183,7 +183,7 @@ func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent str // try to match terminal rules, easiest to distinguish for _, r := range r.term { // match terminal rule - match, err := g.termRuleMatch(r, fid, first, r.usedVars, indent) + match, err := g.termRuleMatch(defName, r, fid, first, r.usedVars, indent) if err != nil { return err } @@ -193,10 +193,11 @@ func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent str // nested rule clusters for _, r := range r.pref { - err := g.dfsRuleGen(r, fid, first, indent) + err := g.dfsRuleGen(defName, r, fid, first, indent) if err != nil { return err } + first = false } if r.empty != nil { @@ -205,7 +206,7 @@ func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent str // no other rules in block fmt.Fprintf(g.b, "%sreturn ret, true\n", indent) } else { - fmt.Fprintf(g.b, "%s} else {\n", indent) + fmt.Fprintf(g.b, " else {\n") fmt.Fprintf(g.b, "%s return ret, true\n", indent) fmt.Fprintf(g.b, "%s}\n", indent) } @@ -220,24 +221,30 @@ func (g *recursiveGen) dfsRuleGen(r *rulePrefix, fid int, first bool, indent str fmt.Fprintf(g.b, "%s}\n", indent) // otherwise |ret| becomes |var1| for the left recursion // rule body - fmt.Fprintf(g.b, "%svar1 = ret\n", indent) + fmt.Fprintf(g.b, "%svar1 := ret\n", indent) + first = true r.rec.prefix = "" - err := g.dfsRuleGen(r, fid, first, indent) + err := g.dfsRuleGen(defName, r.rec, fid+1, first, indent) if err != nil { return err } } for i := 0; i < nesting; i++ { - fmt.Fprintf(g.b, "%s}\n", indent) indent = indent[2:] + fmt.Fprintf(g.b, "\n%s}\n", indent) + } + if fid == 1 { + //only top level rule closes function body + fmt.Fprintf(g.b, "\n%sreturn ret, matched\n", indent) + indent = indent[2:] + fmt.Fprintf(g.b, "%s}\n\n", indent) } - fmt.Fprintf(g.b, "%sreturn ret, matched\n", indent) return nil } -func (g *recursiveGen) termRuleMatch(r *rule, fid int, first bool, usedVars int64, indent string) (string, error) { +func (g *recursiveGen) termRuleMatch(defName string, r *rule, fid int, first bool, usedVars int64, indent string) (string, error) { var b strings.Builder // nest the first token @@ -245,21 +252,26 @@ func (g *recursiveGen) termRuleMatch(r *rule, fid int, first bool, usedVars int6 if err != nil { return "", err } + fmt.Fprintf(&b, match) fid++ - indent += " " // rest of tokens have to match var okDefined bool - for i, f := range r.fields[1:] { - match, okDefined, err = g.termMatch(f, r.fields[:i], fid, first, okDefined, r.usedVars, indent) + for _, f := range r.fields[1:] { + match, okDefined, err = g.termMatch(defName, f, r.name, fid, first, okDefined, r.usedVars, indent+" ") if err != nil { return "", err } fid++ fmt.Fprintf(&b, match) } + for _, l := range r.body { + fmt.Fprintf(&b, " %s%s\n", indent, l) + } // if all tokens match, set |matched| var - fmt.Fprintf(&b, "%smatched = true\n", indent) + fmt.Fprintf(&b, " %smatched = true\n", indent) + + fmt.Fprintf(&b, "%s}", indent) return b.String(), nil } @@ -283,11 +295,11 @@ func (g *recursiveGen) nestMatch(f string, fid int, first bool, usedVars int64, if first { fmt.Fprintf(&b, "%sif ", indent) } else { - fmt.Fprintf(&b, "%selse if ", indent) + fmt.Fprintf(&b, " else if ") } if cmp != "" { - fmt.Fprintf(&b, "%sid, _ := p.peek(); id == %s {\n", indent, cmp) + fmt.Fprintf(&b, "id, _ := p.peek(); id == %s {\n", cmp) if setIncludes(usedVars, fid) { fmt.Fprintf(&b, "%s _, var%d := p.next()\n", indent, fid) } else { @@ -295,15 +307,15 @@ func (g *recursiveGen) nestMatch(f string, fid int, first bool, usedVars int64, } } else { if setIncludes(usedVars, fid) { - fmt.Fprintf(&b, "%svar%d, ok := p.%s(yylex); ok {\n", indent, fid, f) + fmt.Fprintf(&b, "var%d, ok := p.%s(yylex); ok {\n", fid, f) } else { - fmt.Fprintf(&b, "%s_, ok := p.%s(yylex); ok {\n", indent, f) + fmt.Fprintf(&b, "_, ok := p.%s(yylex); ok {\n", f) } } return b.String(), nil } -func (g *recursiveGen) termMatch(f string, priorFields []string, fid int, first, okDefined bool, usedVars int64, indent string) (string, bool, error) { +func (g *recursiveGen) termMatch(defName, f string, ruleFields string, fid int, first, okDefined bool, usedVars int64, indent string) (string, bool, error) { var b strings.Builder var cmp string if f == "openb" { @@ -320,24 +332,24 @@ func (g *recursiveGen) termMatch(f string, priorFields []string, fid int, first, } if cmp != "" { - fmt.Fprintf(&b, " id%d, var%d := p.next()\n", fid, fid) - fmt.Fprintf(&b, " if id%d != %s {\n", fid, cmp) - fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: '\" + string(var%d) + \"'\")\n", f, strings.Join(priorFields, " "), cmp, fid) - fmt.Fprintf(&b, " }\n") + fmt.Fprintf(&b, "%sid%d, var%d := p.next()\n", indent, fid, fid) + fmt.Fprintf(&b, "%sif id%d != %s {\n", indent, fid, cmp) + fmt.Fprintf(&b, "%s p.fail(\"rule: '%s->%s', field %d expected '<%s>', found: '\" + string(var%d) + \"'\")\n", indent, defName, ruleFields, fid, f, fid) + fmt.Fprintf(&b, "%s}\n", indent) } else if _, ok := g.funcExprs[f]; ok { - fmt.Fprintf(&b, " _, tok%d := p.peek()\n", fid) + fmt.Fprintf(&b, "%s_, tok%d := p.peek()\n", indent, fid) if setIncludes(usedVars, fid) { - fmt.Fprintf(&b, " var%d, ok := p.%s(yylex)\n", fid, f) + fmt.Fprintf(&b, "%svar%d, ok := p.%s(yylex)\n", indent, fid, f) okDefined = true } else if okDefined { - fmt.Fprintf(&b, " _, ok = p.%s(yylex)\n", f) + fmt.Fprintf(&b, "%s_, ok = p.%s(yylex)\n", indent, f) } else { - fmt.Fprintf(&b, " _, ok := p.%s(yylex)\n", f) + fmt.Fprintf(&b, "%s_, ok := p.%s(yylex)\n", indent, f) okDefined = true } - fmt.Fprintf(&b, " if !ok&{\n") - fmt.Fprintf(&b, " p.fail(\"expected: '%s: %s <%s>', found: '\"+string(tok%d)+\"'\")\n", f, strings.Join(priorFields, " "), f, fid) - fmt.Fprintf(&b, " }\n") + fmt.Fprintf(&b, "%sif !ok {\n", indent) + fmt.Fprintf(&b, "%s p.fail(\"rule: '%s->%s', field %d expected '<%s>', found: '\"+string(tok%d)+\"'\")\n", indent, defName, ruleFields, fid, f, fid) + fmt.Fprintf(&b, "%s}\n", indent) } return b.String(), okDefined, nil } diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 9faa4ee8aeb..5925c9ca804 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -176,6 +176,9 @@ func split(infile io.Reader) (*yaccFileContents, error) { r = nil } if d != nil { + if err := d.finalize(); err != nil { + return nil, err + } yc.defs = append(yc.defs, d) } d = newDef() @@ -246,15 +249,20 @@ func (d *rulePrefix) calcUsed() { func (d *rulePrefix) partition(name string) { d.calcUsed() j := 0 - for i := 0; i < len(d.term); i++ { - if len(d.term[i].fields) == 0 { - // empty rule is special, checked last - d.empty = d.term[i] - d.term = append(d.term[:i], d.term[i+1:]...) - i-- - continue + for i := 0; i <= len(d.term); i++ { + if i < len(d.term) { + if len(d.term[i].fields) == 1 && d.term[i].fields[0] == "/*empty*/" { + d.term[i].fields = nil + } + if len(d.term[i].fields) == 0 { + // empty rule is special, checked last + d.empty = d.term[i] + d.term = append(d.term[:i], d.term[i+1:]...) + i-- + continue + } } - if d.term[i].fields[0] != d.term[j].fields[0] { + if i == len(d.term) || d.term[i].fields[0] != d.term[j].fields[0] { if i-j > 1 { // leading field doesn't match, but sequence did // new partition for the sequence @@ -275,25 +283,7 @@ func (d *rulePrefix) partition(name string) { d.pref = append(d.pref, p) } } - } - } - if d.term[j-1].fields[0] == d.term[j].fields[0] && len(d.term)-j > 1 { - // leading field doesn't match, but sequence did - // new partition for the sequence - // recursively partition the subsequence - p := new(rulePrefix) - p.prefix = d.term[j].fields[0] - p.term = make([]*rule, len(d.term)-j) - copy(p.term, d.term[j:len(d.term)]) - d.term = append(d.term[:j], d.term[len(d.term):]...) - for _, r := range p.term { - r.fields = r.fields[1:] - } - p.partition(name) - if p.prefix == name { - d.rec = p - } else { - d.pref = append(d.pref, p) + j = i } } } diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 06c96eff2ca..c488055218b 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -147,13 +147,16 @@ func TestLeftRecursion(t *testing.T) { expr Expr } -%token OR AND NOT +%token null_opt OR AND NOT %token value_expr -value_expr: +null_opt: { $$ = nil } +| NULL + +value_expr: | value_expr OR value_expr { $$ = &Or{$1, $3} @@ -164,11 +167,11 @@ value_expr: } | NOT value_expr { - $$ = &Not{$1} + $$ = &Not{$2} } | value_expr NOT AND value_expr { - $$ = &Or{&Not{$1|, &Not{$4}} + $$ = &Or{&Not{$1}, &Not{$4}} } | value_expr NOT OR value_expr { @@ -176,7 +179,7 @@ value_expr: } | NOT EXISTS value_expr { - $$ = &Not{&Exists{$1}} + $$ = &Not{&Exists{$3}} } ` inp := strings.NewReader(y) From 83109975cb865f40524acb38a02ff95a24b44f67 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Wed, 25 Sep 2024 18:01:46 -0700 Subject: [PATCH 10/14] more fixes --- go/vt/sqlparser/gen/rd/generator.go | 22 ++++++++++++++++++---- go/vt/sqlparser/gen/rd/split.go | 3 +++ go/vt/sqlparser/gen/rd/split_test.go | 6 +++++- go/vt/sqlparser/sql.y | 2 +- 4 files changed, 27 insertions(+), 6 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index abbd4a7e430..68b86bb165f 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -216,12 +216,15 @@ func (g *recursiveGen) dfsRuleGen(defName string, r *rulePrefix, fid int, first // field match is different, because it's whether we've matched current scope if r.rec != nil { // if no match, we don't recurse + fmt.Fprintf(g.b, "\n") fmt.Fprintf(g.b, "%sif !matched {\n", indent) fmt.Fprintf(g.b, "%s return ret, false\n", indent) fmt.Fprintf(g.b, "%s}\n", indent) // otherwise |ret| becomes |var1| for the left recursion // rule body - fmt.Fprintf(g.b, "%svar1 := ret\n", indent) + if setIncludes(r.rec.usedVars, 1) { + fmt.Fprintf(g.b, "%svar1 := ret\n", indent) + } first = true r.rec.prefix = "" @@ -233,7 +236,7 @@ func (g *recursiveGen) dfsRuleGen(defName string, r *rulePrefix, fid int, first for i := 0; i < nesting; i++ { indent = indent[2:] - fmt.Fprintf(g.b, "\n%s}\n", indent) + fmt.Fprintf(g.b, "\n%s}", indent) } if fid == 1 { //only top level rule closes function body @@ -252,7 +255,7 @@ func (g *recursiveGen) termRuleMatch(defName string, r *rule, fid int, first boo if err != nil { return "", err } - fmt.Fprintf(&b, match) + fmt.Fprint(&b, match) fid++ // rest of tokens have to match @@ -263,11 +266,17 @@ func (g *recursiveGen) termRuleMatch(defName string, r *rule, fid int, first boo return "", err } fid++ - fmt.Fprintf(&b, match) + fmt.Fprint(&b, match) + } + + if len(r.body) == 0 { + fmt.Fprintf(&b, " %sret = var1\n", indent) + } for _, l := range r.body { fmt.Fprintf(&b, " %s%s\n", indent, l) } + // if all tokens match, set |matched| var fmt.Fprintf(&b, " %smatched = true\n", indent) @@ -287,6 +296,8 @@ func (g *recursiveGen) nestMatch(f string, fid int, first bool, usedVars int64, cmp = "'}'" } else if f == "{" { cmp = "'{'" + } else if f == "'%'" { + cmp = "'%%'" } else if _, ok := g.funcExprs[f]; ok { } else { cmp = f @@ -326,6 +337,8 @@ func (g *recursiveGen) termMatch(defName, f string, ruleFields string, fid int, cmp = "'}'" } else if f == "{" { cmp = "'{'" + } else if f == "'%'" { + cmp = "'%%%'" } else if _, ok := g.funcExprs[f]; ok { } else { cmp = f @@ -458,6 +471,7 @@ func (g *recursiveGen) termMatch(defName, f string, ruleFields string, fid int, var variableRe = regexp.MustCompile("(New\\w*\\()*\\$([1-6]+[0-9]*|[1-9])") func normalizeBodyLine(r string) (string, int64, error) { + r = strings.ReplaceAll(r, "%", "%%") r = strings.ReplaceAll(r, "$$ =", "ret =") r = strings.ReplaceAll(r, "return 1", "return ret, false") diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 5925c9ca804..53982951892 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -229,6 +229,9 @@ func (d *def) finalize() error { } func (r *rule) calcUsed() error { + if len(r.body) == 0 { + r.usedVars |= 1 << 1 + } for i, b := range r.body { newB, used, err := normalizeBodyLine(b) if err != nil { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index c488055218b..8c4020b4980 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -147,9 +147,13 @@ func TestLeftRecursion(t *testing.T) { expr Expr } -%token null_opt OR AND NOT +%token null_opt OR AND NOT TOKEN_A TOKEN_B tokens %token value_expr +tokens: + TOKEN_A +| TOKEN_B + null_opt: { $$ = nil diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index ee9be60a5a7..86b97617ca1 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -6192,7 +6192,7 @@ comment_opt: } comment_list { - $$ = $2 + $$ = $1 setAllowComments(yylex, false) } From c29399f66aea67d36e21cb6f1832ede794e8f06f Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Fri, 27 Sep 2024 19:57:19 -0700 Subject: [PATCH 11/14] disambiguation test working --- go/vt/sqlparser/gen/rd/generator.go | 4 + go/vt/sqlparser/gen/rd/split.go | 279 +++++++++++++++++++++------ go/vt/sqlparser/gen/rd/split_test.go | 202 +++++++++++++------ 3 files changed, 368 insertions(+), 117 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 68b86bb165f..88f73775aec 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -180,6 +180,10 @@ func (g *recursiveGen) dfsRuleGen(defName string, r *rulePrefix, fid int, first nesting++ fmt.Fprintf(g.b, match) } + + if r.prefix == "value_expression" { + print() + } // try to match terminal rules, easiest to distinguish for _, r := range r.term { // match terminal rule diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 53982951892..9dd75a9c880 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -18,7 +18,7 @@ type yaccFileContents struct { yaccTypes []yaccType tokens []yaccToken start string - defs []*def + defs map[string]*def } type goType struct { @@ -39,6 +39,7 @@ type yaccToken struct { type def struct { name string rules *rulePrefix + done bool } func newDef() *def { @@ -50,29 +51,37 @@ func newDef() *def { type rule struct { name string fields []string - start bool + set bool body []string usedVars int64 } type rulePrefix struct { prefix string + flat []*rule term []*rule pref []*rulePrefix rec *rulePrefix empty *rule usedVars int64 + done bool } -func split(infile io.Reader) (*yaccFileContents, error) { +func split(infile io.Reader) (yc *yaccFileContents, err error) { sc := bufio.NewScanner(infile) var buf []string var acc bool var d *def var r *rule - var err error var nesting int - yc := new(yaccFileContents) + yc = new(yaccFileContents) + yc.defs = make(map[string]*def) + defer func() { + if err != nil { + return + } + err = yc.finalize() + }() for sc.Scan() { line := sc.Text() line = strings.TrimSpace(line) @@ -91,7 +100,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { if r == nil { r = new(rule) } - r.start = true + r.set = true continue case "%{": @@ -111,7 +120,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { if nesting > 0 { nesting-- } else if d != nil { - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) r = nil continue } else { @@ -126,6 +135,12 @@ func split(infile io.Reader) (*yaccFileContents, error) { case "%%": continue case "{}": + if d != nil { + r := new(rule) + r.set = true + r.body = []string{"$$ = nil"} + d.rules.empty = r + } continue } @@ -133,8 +148,9 @@ func split(infile io.Reader) (*yaccFileContents, error) { if r == nil { r = new(rule) } + r.set = true r.body = append(r.body, strings.TrimSpace(line[1:len(line)-1])) - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) r = nil continue } @@ -164,7 +180,7 @@ func split(infile io.Reader) (*yaccFileContents, error) { } else if strings.HasPrefix(line, "%start") { yc.start = strings.Split(line, " ")[1] } else if strings.HasPrefix(line, "|") && r != nil { - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) r = nil } else if strings.HasPrefix(line, "} else") && r != nil { nesting-- @@ -172,14 +188,11 @@ func split(infile io.Reader) (*yaccFileContents, error) { if line[len(line)-1] == ':' && !strings.HasPrefix(line, "case ") { if r != nil { - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) r = nil } if d != nil { - if err := d.finalize(); err != nil { - return nil, err - } - yc.defs = append(yc.defs, d) + yc.defs[d.name] = d } d = newDef() d.name = line[:len(line)-1] @@ -192,10 +205,11 @@ func split(infile io.Reader) (*yaccFileContents, error) { r.body = append(r.body, line) } else if d != nil { r = new(rule) + r.set = true if strings.HasSuffix(line, "{}") { line = line[:len(line)-2] r.name = parseRuleName(line) - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) r = nil continue } @@ -203,28 +217,20 @@ func split(infile io.Reader) (*yaccFileContents, error) { } } if r != nil { - d.rules.term = append(d.rules.term, r) + d.rules.addRule(r) } if d != nil { - if err := d.finalize(); err != nil { - return nil, err - } - yc.defs = append(yc.defs, d) + yc.defs[d.name] = d } return yc, nil } -func (d *def) finalize() error { - sort.Slice(d.rules.term, func(i, j int) bool { - return d.rules.term[i].name < d.rules.term[j].name - }) - for _, r := range d.rules.term { - if err := r.calcUsed(); err != nil { +func (yc *yaccFileContents) finalize() error { + for _, d := range yc.defs { + if err := d.rules.finalize(d.name, yc.defs); err != nil { return err } - r.fields = strings.Fields(r.name) } - d.rules.partition(d.name) return nil } @@ -249,46 +255,197 @@ func (d *rulePrefix) calcUsed() { } } -func (d *rulePrefix) partition(name string) { - d.calcUsed() - j := 0 - for i := 0; i <= len(d.term); i++ { - if i < len(d.term) { - if len(d.term[i].fields) == 1 && d.term[i].fields[0] == "/*empty*/" { - d.term[i].fields = nil - } - if len(d.term[i].fields) == 0 { - // empty rule is special, checked last - d.empty = d.term[i] - d.term = append(d.term[:i], d.term[i+1:]...) - i-- - continue +func (d *rulePrefix) addRule(r *rule) { + d.flat = append(d.flat, r) +} + +func (d *rulePrefix) recurseChildren(name string, defs map[string]*def) error { + // expand/partition children first + for _, r := range d.flat { + for _, f := range r.fields { + if d, ok := defs[f]; ok { + if err := d.rules.finalize(f, defs); err != nil { + return err + } } } - if i == len(d.term) || d.term[i].fields[0] != d.term[j].fields[0] { - if i-j > 1 { - // leading field doesn't match, but sequence did - // new partition for the sequence - // recursively partition the subsequence - p := new(rulePrefix) - p.prefix = d.term[j].fields[0] - p.term = make([]*rule, i-j) - copy(p.term, d.term[j:i]) - d.term = append(d.term[:j], d.term[i:]...) - for _, r := range p.term { - r.fields = r.fields[1:] + } + return nil +} + +func (d *rulePrefix) expandConflicts(name string, defs map[string]*def) { + // fixed point iteration, weasel out conflicts for this prefix level + // look at first field, store which we've seen + + // token in r, conflicting starting token in r2 + // two different r2's have conflicting starting token + nextTokens := make(map[string]bool) + for _, r := range d.flat { + // toplevel next tokens + if len(r.fields) == 0 { + continue + } + nextTokens[r.fields[0]] = true + } + ignore := make(map[string]bool) + for { + var conflicts []*rule + for _, r := range d.flat { + // find nested conflicts + if d, ok := defs[r.name]; ok { + // next token is a function, go one deeper + for _, r2 := range d.rules.flat { + // todo flat needs all fields + if len(r2.fields) == 0 { + continue + } + if nextTokens[r2.fields[0]] && !ignore[r2.fields[0]] { + // lookahead conflict + // advance rule + conflicts = append(conflicts, r2) + } } - i = j - p.partition(name) - if p.prefix == name { - d.rec = p - } else { - d.pref = append(d.pref, p) + for _, r2 := range d.rules.flat { + // catch inter-child-rule conflicts + // this takes two cycles to unwind + if len(r2.fields) == 0 { + continue + } + nextTokens[r2.fields[0]] = true } + nextTokens[d.name] = true } - j = i } + if len(conflicts) == 0 { + break + } + // remove + for _, r := range conflicts { + // prevent looping + ignore[r.fields[0]] = true + } + d.flat = append(d.flat, conflicts...) + conflicts = conflicts[:0] } + return +} + +func (d *rulePrefix) finalize(name string, defs map[string]*def) error { + if d.done { + return nil + } + d.done = true + + for _, r := range d.flat { + if err := r.calcUsed(); err != nil { + return err + } + r.fields = strings.Fields(r.name) + } + d.calcUsed() + + if err := d.recurseChildren(name, defs); err != nil { + return err + } + + d.expandConflicts(name, defs) + + if name == "expression" { + print() + } + + return d.partition(name) +} + +func (r *rule) copy() *rule { + nr := new(rule) + nr.fields = make([]string, len(r.fields)) + nr.body = make([]string, len(r.body)) + copy(nr.fields, r.fields) + copy(nr.body, r.body) + nr.set = true + nr.body = r.body + nr.usedVars = r.usedVars + nr.name = r.name + return nr +} + +func (d *rulePrefix) addPrefixPartition(name string, rules []*rule) error { + newRules := make([]*rule, len(rules)) + for i, r := range rules { + newRules[i] = r.copy() + } + p := new(rulePrefix) + p.prefix = rules[0].fields[0] + p.flat = newRules + for _, r := range p.flat { + r.fields = r.fields[1:] + } + if err := p.partition(""); err != nil { + return err + } + if p.prefix == name { + d.rec = p + } else { + d.pref = append(d.pref, p) + } + return nil +} + +func (d *rulePrefix) partition(name string) error { + d.calcUsed() + + if len(d.flat) == 1 { + r := d.flat[0] + if len(r.fields) == 0 || len(r.fields) == 1 && r.fields[0] == "/*empty*/" { + r.fields = nil + d.empty = r + return nil + } + } + + sort.Slice(d.flat, func(i, j int) bool { + return d.flat[i].name < d.flat[j].name + }) + + var acc []*rule + for _, r := range d.flat { + if len(r.fields) == 1 && r.fields[0] == "/*empty*/" { + r.fields = nil + } + if len(r.fields) == 0 { + // empty rule is special, checked last + d.empty = r + continue + } + + if len(acc) == 0 { + acc = append(acc, r) + continue + } + + match := acc[0].fields[0] == r.fields[0] + if !match { + if len(acc) < 2 { + d.term = append(d.term, acc[0]) + } else { + if err := d.addPrefixPartition(name, acc); err != nil { + return err + } + } + acc = acc[:0] + } + acc = append(acc, r) + } + if len(acc) == 1 { + d.term = append(d.term, acc[0]) + } else if len(acc) > 0 { + if err := d.addPrefixPartition(name, acc); err != nil { + return err + } + } + + return nil } func parseRuleName(s string) string { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 8c4020b4980..8c7e5c47d72 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -147,7 +147,7 @@ func TestLeftRecursion(t *testing.T) { expr Expr } -%token null_opt OR AND NOT TOKEN_A TOKEN_B tokens +%token null_opt OR AND NOT TOKEN_A TOKEN_B tokens row_opt ROW %token value_expr tokens: @@ -160,6 +160,11 @@ null_opt: } | NULL +row_opt: + {} +| ROW + {} + value_expr: | value_expr OR value_expr { @@ -194,6 +199,91 @@ value_expr: fmt.Println(g.b.String()) } +func TestConflicts(t *testing.T) { + y := ` +%union { + expr Expr +} + +%token null_opt OR AND NOT TOKEN_A TOKEN_B tokens row_opt ROW ID +%token value_expr condition expression + +expression: + condition + { + $$ = $1 + } +| expression AND expression + { + $$ = &AndExpr{Left: $1, Right: $3} + } +| NOT expression + { + $$ = &NotExpr{Expr: $2} + } +| value_expression + { + $$ = $1 + } +| DEFAULT default_opt + { + $$ = &Default{ColName: $2} + } + +value_expression: +| value_expression OR value_expression + { + $$ = &Or{$1, $3} + } +| value_expression AND value_expression + { + $$ = &And{$1, $3} + } +| NOT value_expression + { + $$ = &Not{$2} + } +| value_expression NOT AND value_expression + { + $$ = &Or{&Not{$1}, &Not{$4}} + } +| value_expression NOT OR value_expression + { + $$ = &And{&Not{$1}, &Not{$4}} + } +| NOT EXISTS value_expr + { + $$ = &Not{&Exists{$3}} + } + +condition: + value_expression compare value_expression + { + $$ = &ComparisonExpr{Left: $1, Operator: $2, Right: $3} + } +| value_expression IN col_tuple + { + $$ = &ComparisonExpr{Left: $1, Operator: InStr, Right: $3} + } + +default_opt: + /*empty*/ + { + $$ = "" + } +| openb ID closeb + { + $$ = string($2) + } +` + inp := strings.NewReader(y) + g := newRecursiveGen(inp, emptyWriter{}) + err := g.init() + require.NoError(t, err) + err = g.gen() + fmt.Println(g.b.String()) +} + func TestSplit(t *testing.T) { inp := strings.NewReader(testY) cmp, err := split(inp) @@ -217,39 +307,39 @@ func TestSplit(t *testing.T) { }, tokens: nil, start: "any_command", - defs: []*def{ - { + defs: map[string]*def{ + "any_command": { name: "any_command", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "command", - start: true, - body: []string{"setParseTree(yylex, $1)"}, + name: "command", + set: true, + body: []string{"setParseTree(yylex, $1)"}, }, { - name: "command ';'", - start: true, - body: []string{"setParseTree(yylex, $1)", "statementSeen(yylex)"}, + name: "command ';'", + set: true, + body: []string{"setParseTree(yylex, $1)", "statementSeen(yylex)"}, }, }, }, }, - { + "command": { name: "command", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "select_statement", - start: true, - body: []string{"$$ = $1"}, + name: "select_statement", + set: true, + body: []string{"$$ = $1"}, }, { - name: "values_select_statement", - start: true, - body: []string{"$$ = $1"}, + name: "values_select_statement", + set: true, + body: []string{"$$ = $1"}, }, { name: "stream_statement", @@ -258,73 +348,73 @@ func TestSplit(t *testing.T) { name: "insert_statement", }, { - name: "/*empty*/", - start: true, - body: []string{"setParseTree(yylex, nil)"}, + name: "/*empty*/", + set: true, + body: []string{"setParseTree(yylex, nil)"}, }, }, }, }, - { + "set_opt": { name: "set_opt", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "", - start: true, - body: []string{"$$ = nil"}, + name: "", + set: true, + body: []string{"$$ = nil"}, }, { - name: "SET assignment_list", - start: true, - body: []string{"$$ = $2"}, + name: "SET assignment_list", + set: true, + body: []string{"$$ = $2"}, }, }, }, }, - { + "load_statement": { name: "load_statement", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt", - start: true, + name: "LOAD DATA local_opt infile_opt ignore_or_replace_opt load_into_table_name opt_partition_clause charset_opt fields_opt lines_opt ignore_number_opt column_list_opt set_opt", + set: true, body: []string{ "$$ = &Load{Local: $3, Infile: $4, IgnoreOrReplace: $5, Table: $6, Partition: $7, Charset: $8, Fields: $9, Lines: $10, IgnoreNum: $11, Columns: $12, SetExprs: $13}"}, }, }, }, }, - { + "from_or_using": { name: "from_or_using", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "FROM", - start: false, + name: "FROM", + set: false, }, { - name: "USING", - start: false, + name: "USING", + set: false, }, { - name: "OTHER", - start: false, + name: "OTHER", + set: false, }, }, }, }, - { + "select_statement": { name: "select_statement", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "with_select order_by_opt limit_opt lock_opt into_opt", - start: true, + name: "with_select order_by_opt limit_opt lock_opt into_opt", + set: true, body: []string{ "$1.SetOrderBy($2)", "$1.SetLimit($3)", @@ -337,8 +427,8 @@ func TestSplit(t *testing.T) { }, }, { - name: "SELECT comment_opt query_opts NEXT num_val for_from table_name", - start: true, + name: "SELECT comment_opt query_opts NEXT num_val for_from table_name", + set: true, body: []string{ "$$ = &Select{", "Comments: Comments($2),", @@ -351,41 +441,41 @@ func TestSplit(t *testing.T) { }, }, }, - { + "join_condition": { name: "join_condition", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "", - start: false, - body: []string{"$$ = JoinCondition{On: $2}"}, + name: "", + set: false, + body: []string{"$$ = JoinCondition{On: $2}"}, }, { - name: "ON expression", - start: false, - body: []string{"$$ = JoinCondition{On: $2}"}, + name: "ON expression", + set: false, + body: []string{"$$ = JoinCondition{On: $2}"}, }, { - name: "USING '(' column_list ')'", - start: false, - body: []string{"$$ = JoinCondition{Using: $3}"}, + name: "USING '(' column_list ')'", + set: false, + body: []string{"$$ = JoinCondition{Using: $3}"}, }, }, }, }, - { + "func_parens_opt": { name: "func_parens_opt", rules: &rulePrefix{ prefix: "", term: []*rule{ { - name: "/*empty*/", - start: false, + name: "/*empty*/", + set: false, }, { - name: "openb closeb", - start: false, + name: "openb closeb", + set: false, }, }, }, From 0df62921ce8a1290fd4ae01c0d6fac013353a9f6 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Mon, 30 Sep 2024 21:00:20 -0700 Subject: [PATCH 12/14] progress converting left-recursion to right-recursion --- go/vt/sqlparser/gen/rd/generator.go | 3 +- go/vt/sqlparser/gen/rd/split.go | 137 ++++++++++++++++++++++++--- go/vt/sqlparser/gen/rd/split_test.go | 61 +++++++++++- 3 files changed, 185 insertions(+), 16 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/generator.go b/go/vt/sqlparser/gen/rd/generator.go index 88f73775aec..93cc07b8b69 100644 --- a/go/vt/sqlparser/gen/rd/generator.go +++ b/go/vt/sqlparser/gen/rd/generator.go @@ -75,7 +75,8 @@ func (g *recursiveGen) gen() error { return err } // each function - for _, d := range g.yacc.defs { + for _, n := range g.yacc.defNames { + d := g.yacc.defs[n] if err := g.genFunc(d); err != nil { return err } diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index 9dd75a9c880..f3f850466be 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -19,6 +19,13 @@ type yaccFileContents struct { tokens []yaccToken start string defs map[string]*def + defNames []string +} + +func (yc *yaccFileContents) addDef(d *def) { + yc.defNames = append(yc.defNames, d.name) + yc.defs[d.name] = d + return } type goType struct { @@ -192,7 +199,7 @@ func split(infile io.Reader) (yc *yaccFileContents, err error) { r = nil } if d != nil { - yc.defs[d.name] = d + yc.addDef(d) } d = newDef() d.name = line[:len(line)-1] @@ -220,7 +227,7 @@ func split(infile io.Reader) (yc *yaccFileContents, err error) { d.rules.addRule(r) } if d != nil { - yc.defs[d.name] = d + yc.addDef(d) } return yc, nil } @@ -250,7 +257,7 @@ func (r *rule) calcUsed() error { } func (d *rulePrefix) calcUsed() { - for _, t := range d.term { + for _, t := range d.flat { d.usedVars |= t.usedVars } } @@ -279,15 +286,21 @@ func (d *rulePrefix) expandConflicts(name string, defs map[string]*def) { // token in r, conflicting starting token in r2 // two different r2's have conflicting starting token - nextTokens := make(map[string]bool) + nextTokens := make(map[string]string) for _, r := range d.flat { // toplevel next tokens if len(r.fields) == 0 { continue } - nextTokens[r.fields[0]] = true + nextTokens[r.fields[0]] = r.name } ignore := make(map[string]bool) + + // don't expand self-recursive + ignore[name] = true + if name == "table_name_list" { + print() + } for { var conflicts []*rule for _, r := range d.flat { @@ -296,13 +309,45 @@ func (d *rulePrefix) expandConflicts(name string, defs map[string]*def) { // next token is a function, go one deeper for _, r2 := range d.rules.flat { // todo flat needs all fields - if len(r2.fields) == 0 { + if len(r2.fields) == 0 || r2.name == r.name { continue } - if nextTokens[r2.fields[0]] && !ignore[r2.fields[0]] { + if rc, ok := nextTokens[r2.fields[0]]; ok && rc != r.name && !ignore[r2.fields[0]] { // lookahead conflict // advance rule - conflicts = append(conflicts, r2) + if name == "table_name_list" { + print() + } + _, ok := defs[r2.fields[0]] + nr2 := r2.copy() + if len(r.body) > 0 && ok && len(r2.body) > 0 { + // previous return is wrong type + // rename |ret| to |varx| + // replace |var1| with |varx| in |r.body| + for i, l := range nr2.body { + if l == "ret = BoolVal(false)" { + print() + } + l = strings.ReplaceAll(l, "ret = ", "varx := ") + l = strings.ReplaceAll(l, "ret.", "varx.") + nr2.body[i] = l + } + callerBody := make([]string, len(r.body)) + for i, l := range r.body { + if strings.Contains(l, "yylex.Error") { + callerBody = []string{l, "return ret, false"} + nr2.body = nil + break + } + l = strings.ReplaceAll(l, "var1", "varx") + callerBody[i] = l + } + nr2.body = append(nr2.body, callerBody...) + } else { + // same type return + } + nr2.calcUsed() + conflicts = append(conflicts, nr2) } } for _, r2 := range d.rules.flat { @@ -311,9 +356,9 @@ func (d *rulePrefix) expandConflicts(name string, defs map[string]*def) { if len(r2.fields) == 0 { continue } - nextTokens[r2.fields[0]] = true + nextTokens[r2.fields[0]] = r2.name } - nextTokens[d.name] = true + nextTokens[d.name] = d.name } } if len(conflicts) == 0 { @@ -342,7 +387,6 @@ func (d *rulePrefix) finalize(name string, defs map[string]*def) error { } r.fields = strings.Fields(r.name) } - d.calcUsed() if err := d.recurseChildren(name, defs); err != nil { return err @@ -350,13 +394,79 @@ func (d *rulePrefix) finalize(name string, defs map[string]*def) error { d.expandConflicts(name, defs) - if name == "expression" { + if name == "any_command" { print() } + if err := d.replaceLeftRecursion(name); err != nil { + return err + } + return d.partition(name) } +func (d *rulePrefix) replaceLeftRecursion(name string) error { + if name == "tuple_list" { + print() + } + // call this before partition + term := make(map[string]bool) + var recStart int = -1 + var recEnd = -1 + for i := 0; i < len(d.flat); i++ { + r := d.flat[i] + if fs := r.fields; len(fs) > 0 && fs[0] == name { + if recStart < 0 { + recStart = i + } + continue + } + if recStart > 0 && recEnd < 0 { + recEnd = i + continue + } + term[strings.Join(r.fields, " ")] = true + } + if recStart < 0 { + return nil + } + if recEnd < 0 { + recEnd = len(d.flat) + } + + //newRec := make([]*rule, recEnd-recStart) + for i := recStart; i < recEnd; i++ { + r := d.flat[i] + for i := 1; i < len(r.fields); i++ { + suf := strings.Join(r.fields[i:], " ") + if term[suf] { + // direct left recursion + // expr -> (term) | (expr term) + //nr := r.copy() + newFields := append([]string{suf}, r.fields[1:i]...) + newFields = append(newFields, name) + r.fields = newFields + totalFields := len(strings.Fields(r.name)) + offset := totalFields - len(r.fields) + from := fmt.Sprintf("var%d", offset+1) + to := fmt.Sprintf("var%d", totalFields) + for i, l := range r.body { + // XXX: this only works when recursive list rules are <10 fields + l = strings.ReplaceAll(l, to, "varx") + l = strings.ReplaceAll(l, from, to) + l = strings.ReplaceAll(l, "varx", from) + l = strings.ReplaceAll(l, "append(ret", "append("+to) + r.body[i] = l + } + r.calcUsed() + break + } + } + } + //copy(d.flat[recStart:recEnd], newRec) + return nil +} + func (r *rule) copy() *rule { nr := new(rule) nr.fields = make([]string, len(r.fields)) @@ -364,7 +474,6 @@ func (r *rule) copy() *rule { copy(nr.fields, r.fields) copy(nr.body, r.body) nr.set = true - nr.body = r.body nr.usedVars = r.usedVars nr.name = r.name return nr @@ -437,7 +546,7 @@ func (d *rulePrefix) partition(name string) error { } acc = append(acc, r) } - if len(acc) == 1 { + if len(acc) == 1 && acc[0].fields[0] != name { d.term = append(d.term, acc[0]) } else if len(acc) > 0 { if err := d.addPrefixPartition(name, acc); err != nil { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index 8c7e5c47d72..eea5257102e 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -147,7 +147,7 @@ func TestLeftRecursion(t *testing.T) { expr Expr } -%token null_opt OR AND NOT TOKEN_A TOKEN_B tokens row_opt ROW +%token TRUE FALSE null_opt OR AND NOT TOKEN_A TOKEN_B tokens row_opt ROW %token value_expr tokens: @@ -166,6 +166,10 @@ row_opt: {} value_expr: + boolean_value + { + $$ = $1 + } | value_expr OR value_expr { $$ = &Or{$1, $3} @@ -190,6 +194,61 @@ value_expr: { $$ = &Not{&Exists{$3}} } + +boolean_value: + TRUE + { + $$ = BoolVal(true) + } +| FALSE + { + $$ = BoolVal(false) + } +` + inp := strings.NewReader(y) + g := newRecursiveGen(inp, emptyWriter{}) + err := g.init() + require.NoError(t, err) + err = g.gen() + fmt.Println(g.b.String()) +} + +func TestListOpt(t *testing.T) { + y := ` +%union { + characteristics Characteristic +} + +%token characteristic_list_opt characteristic_list + +characteristic_list_opt: + { + $$ = nil + } +| characteristic_list + { + $$ = $1 + } + +characteristic_list: + characteristic + { + $$ = []Characteristic{$1} + } +| characteristic_list characteristic + { + $$ = append($$, $2) + } + +characteristic: + COMMENT_KEYWORD STRING + { + $$ = Characteristic{Type: CharacteristicValue_Comment, Comment: string($2)} + } +| LANGUAGE SQL + { + $$ = Characteristic{Type: CharacteristicValue_LanguageSql} + } ` inp := strings.NewReader(y) g := newRecursiveGen(inp, emptyWriter{}) From f8db4ffdf7cda61d6062eb345f3a7f5565db891c Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Tue, 1 Oct 2024 10:54:30 -0700 Subject: [PATCH 13/14] builds and runs inserts --- go/vt/sqlparser/gen/rd/split.go | 77 +++++++++++++++++++--------- go/vt/sqlparser/gen/rd/split_test.go | 43 ++++++++++++++++ 2 files changed, 96 insertions(+), 24 deletions(-) diff --git a/go/vt/sqlparser/gen/rd/split.go b/go/vt/sqlparser/gen/rd/split.go index f3f850466be..424aacbf487 100644 --- a/go/vt/sqlparser/gen/rd/split.go +++ b/go/vt/sqlparser/gen/rd/split.go @@ -437,30 +437,59 @@ func (d *rulePrefix) replaceLeftRecursion(name string) error { //newRec := make([]*rule, recEnd-recStart) for i := recStart; i < recEnd; i++ { r := d.flat[i] - for i := 1; i < len(r.fields); i++ { - suf := strings.Join(r.fields[i:], " ") - if term[suf] { - // direct left recursion - // expr -> (term) | (expr term) - //nr := r.copy() - newFields := append([]string{suf}, r.fields[1:i]...) - newFields = append(newFields, name) - r.fields = newFields - totalFields := len(strings.Fields(r.name)) - offset := totalFields - len(r.fields) - from := fmt.Sprintf("var%d", offset+1) - to := fmt.Sprintf("var%d", totalFields) - for i, l := range r.body { - // XXX: this only works when recursive list rules are <10 fields - l = strings.ReplaceAll(l, to, "varx") - l = strings.ReplaceAll(l, from, to) - l = strings.ReplaceAll(l, "varx", from) - l = strings.ReplaceAll(l, "append(ret", "append("+to) - r.body[i] = l - } - r.calcUsed() - break + var match bool + suffix := strings.Join(r.fields[1:], " ") + if term[suffix] { + // direct left recursion + // expr -> (term) | (expr term) + //nr := r.copy() + match = true + r.fields = append(r.fields[1:], name) + totalFields := len(strings.Fields(r.name)) + offset := totalFields - len(r.fields) + from := fmt.Sprintf("var%d", offset+1) + to := fmt.Sprintf("var%d", totalFields) + for i, l := range r.body { + // XXX: this only works when recursive list rules are <10 fields + l = strings.ReplaceAll(l, to, "varx") + l = strings.ReplaceAll(l, from, to) + l = strings.ReplaceAll(l, "varx", from) + l = strings.ReplaceAll(l, "append(ret", "append("+to) + r.body[i] = l + } + r.calcUsed() + } else if term[r.fields[len(r.fields)-1]] { + match = true + r.fields = append(r.fields[:len(r.fields)-1], name) + totalFields := len(strings.Fields(r.name)) + offset := totalFields - len(r.fields) + from := fmt.Sprintf("var%d", offset+1) + to := fmt.Sprintf("var%d", totalFields) + for i, l := range r.body { + // XXX: this only works when recursive list rules are <10 fields + l = strings.ReplaceAll(l, to, "varx") + l = strings.ReplaceAll(l, from, to) + l = strings.ReplaceAll(l, "varx", from) + l = strings.ReplaceAll(l, "append(ret", "append("+to) + l = strings.ReplaceAll(l, fmt.Sprintf("append(%s, %s)", to, from), fmt.Sprintf("append(%s, %s...)", to, from)) + r.body[i] = l + } + r.calcUsed() + } + if match { + totalFields := len(strings.Fields(r.name)) + offset := totalFields - len(r.fields) + from := fmt.Sprintf("var%d", offset+1) + to := fmt.Sprintf("var%d", totalFields) + for i, l := range r.body { + // XXX: this only works when recursive list rules are <10 fields + l = strings.ReplaceAll(l, to, "varx") + l = strings.ReplaceAll(l, from, to) + l = strings.ReplaceAll(l, "varx", from) + l = strings.ReplaceAll(l, "append(ret", "append("+to) + r.body[i] = l } + r.calcUsed() } } //copy(d.flat[recStart:recEnd], newRec) @@ -535,7 +564,7 @@ func (d *rulePrefix) partition(name string) error { match := acc[0].fields[0] == r.fields[0] if !match { - if len(acc) < 2 { + if len(acc) == 1 && acc[0].fields[0] != name { d.term = append(d.term, acc[0]) } else { if err := d.addPrefixPartition(name, acc); err != nil { diff --git a/go/vt/sqlparser/gen/rd/split_test.go b/go/vt/sqlparser/gen/rd/split_test.go index eea5257102e..e66036e355e 100644 --- a/go/vt/sqlparser/gen/rd/split_test.go +++ b/go/vt/sqlparser/gen/rd/split_test.go @@ -258,6 +258,49 @@ characteristic: fmt.Println(g.b.String()) } +func TestListCommaOpt(t *testing.T) { + y := ` +%union { + valTuple ValTuple + values Values +} + +%type tuple_or_empty +%type tuple_list + +tuple_list: + tuple_or_empty + { + $$ = Values{$1} + } +| tuple_list ',' tuple_or_empty + { + $$ = append($1, $3) + } + +tuple_or_empty: + row_opt openb STRING closeb + { + $$ = ValTuple($3) + } +| row_opt openb closeb + { + $$ = ValTuple{} + } + +row_opt: + {} +| ROW + {} +` + inp := strings.NewReader(y) + g := newRecursiveGen(inp, emptyWriter{}) + err := g.init() + require.NoError(t, err) + err = g.gen() + fmt.Println(g.b.String()) +} + func TestConflicts(t *testing.T) { y := ` %union { From 57138325f20db472540f5de99397fb62e05537f3 Mon Sep 17 00:00:00 2001 From: Max Hoffman Date: Mon, 7 Oct 2024 16:00:31 -0700 Subject: [PATCH 14/14] interface cast automation --- go/vt/sqlparser/ast.go | 63 +- go/vt/sqlparser/gen/rd/type_cast.go | 253 + go/vt/sqlparser/sql.go | 10373 +++++++++++++++++++------- go/vt/sqlparser/sql.y | 200 +- 4 files changed, 8072 insertions(+), 2817 deletions(-) create mode 100644 go/vt/sqlparser/gen/rd/type_cast.go diff --git a/go/vt/sqlparser/ast.go b/go/vt/sqlparser/ast.go index b5fe33a4dfe..5b91b05893b 100644 --- a/go/vt/sqlparser/ast.go +++ b/go/vt/sqlparser/ast.go @@ -16,7 +16,7 @@ limitations under the License. package sqlparser -//go:generate goyacc -o sql.go sql.y +//go:generate goyacc -o sql.go sql3.y import ( "context" @@ -149,7 +149,7 @@ func ParseOneWithOptions(ctx context.Context, sql string, options ParserOptions) } } - return tree, tokenizer.Position-1, nil + return tree, tokenizer.Position - 1, nil } func parseTokenizer(sql string, tokenizer *Tokenizer) (Statement, error) { @@ -599,6 +599,9 @@ func (node *Select) SetInto(into *Into) error { if into == nil { return nil } + if into.Variables == nil && into.Dumpfile == "" && into.Outfile == "" { + return nil + } if node.Into != nil { return fmt.Errorf("Multiple INTO clauses in one query block") } @@ -865,7 +868,7 @@ type Load struct { *Lines IgnoreNum *SQLVal Columns - SetExprs AssignmentExprs + SetExprs AssignmentExprs IgnoreOrReplace string } @@ -3554,6 +3557,52 @@ func (node *AutoIncSpec) walkSubtree(visit Visit) error { return err } +<<<<<<< Updated upstream +======= +// ColumnTypeSpec defines a change to a column's type, without fully specifying the column definition. +type ColumnTypeSpec struct { + Column ColIdent + Type ColumnType +} + +var _ SQLNode = (*ColumnTypeSpec)(nil) + +func (node ColumnTypeSpec) Format(buf *TrackedBuffer) { + buf.Myprintf("alter column %v type ") + node.Type.Format(buf) +} + +// walkSubtree implements SQLNode. +func (node *ColumnTypeSpec) walkSubtree(visit Visit) error { + return Walk(visit, node.Column) +} + +// NotNullSpec defines a SET / DROP on a column for its NOT NULL constraint. +type NotNullSpec struct { + // Action is SET to set a NOT NULL constraint on a column, or DROP to drop + // a NOT NULL constraint on a column. + Action string + Column ColIdent +} + +var _ SQLNode = (*NotNullSpec)(nil) + +// Format implements SQLNode. +func (node *NotNullSpec) Format(buf *TrackedBuffer) { + switch node.Action { + case SetStr: + buf.Myprintf("alter column %v set not null", node.Column) + case DropStr: + buf.Myprintf("alter column %v drop not null", node.Column) + } +} + +// walkSubtree implements SQLNode. +func (node *NotNullSpec) walkSubtree(visit Visit) error { + return Walk(visit, node.Column) +} + +>>>>>>> Stashed changes // DefaultSpec defines a SET / DROP on a column for its default value. type DefaultSpec struct { Action string @@ -3978,7 +4027,7 @@ type FlushOption struct { // PurgeBinaryLogs represents a PURGE BINARY LOGS statement. type PurgeBinaryLogs struct { - To string + To string Before Expr } @@ -4755,7 +4804,7 @@ func (node EventName) IsEmpty() bool { // This means two TableName vars can be compared for equality // and a TableName can also be used as key in a map. // SchemaQualifier, if specified, represents a schema name, which is an additional level of namespace supported in -// other dialects. Supported here so that this AST can act as a translation layer for those dialects, but is unused in +// other dialects. Supported here so that this AST can act as a translation layer for those dialects, but is unused in // MySQL. type TableName struct { Name, DbQualifier, SchemaQualifier TableIdent @@ -7564,8 +7613,8 @@ func (d InjectedExpr) Format(buf *TrackedBuffer) { // InjectedStatement allows bypassing AST analysis. This is used by projects that rely on Vitess, but may not implement // MySQL's dialect. type InjectedStatement struct { - Statement Injectable - Children Exprs + Statement Injectable + Children Exprs } var _ Statement = InjectedStatement{} diff --git a/go/vt/sqlparser/gen/rd/type_cast.go b/go/vt/sqlparser/gen/rd/type_cast.go new file mode 100644 index 00000000000..8ed6a1f060c --- /dev/null +++ b/go/vt/sqlparser/gen/rd/type_cast.go @@ -0,0 +1,253 @@ +package rd + +import ( + "bufio" + "fmt" + "io" + "log" + "regexp" + "strconv" + "strings" +) + +func rewriteTypes(infile io.Reader, outFile io.Writer) (err error) { + sc := bufio.NewScanner(infile) + + var goTypes []goType + var yaccTypes []yaccType + //var defs = make(map[string]*def) + //var defNames []string + + var goTypesMap = make(map[string]string) + var funcExprsMap = make(map[string]string) + //computeTypeLookups := func() error { + // for _, typ := range goTypes { + // goTypesMap[typ.name] = typ.typ + // } + // for _, d := range yaccTypes { + // goTyp, ok := goTypesMap[d.typ] + // if !ok { + // return fmt.Errorf("function expression not found: %s", d.name) + // } + // funcExprsMap[d.name] = goTyp + // } + // return nil + //} + + //varToType := func(fields []string) []string { + // typs := make([]string, len(fields)+1) + // var ok bool + // for i, f := range fields { + // if f == "';'" { + // typs[i+1] = "[]byte" + // } else { + // typs[i+1], ok = funcExprsMap[f] + // if !ok { + // log.Fatalf("missing rule/terminal: %s", f) + // } + // } + // } + // return typs + //} + + castVarTypes := func(l string, typs []string) string { + match := variableRe.FindAllStringSubmatchIndex(l, 1) + for len(match) > 0 { + m := match[0] + start, end := m[4], m[5] + + _int64, err := strconv.ParseInt(l[start:end], 10, 64) + if err != nil { + log.Fatalf("failed to parse variable string: %s", l[start:end]) + } + if _int64 >= 64 { + log.Fatalf("variable reference too big: %d", _int64) + } + //l = l[:start-1] + "var" + l[start:] + typ := typs[_int64-1] + if typ == "[]byte" { + l = fmt.Sprintf("%svarx%s%s", l[:start-1], l[start:end], l[end:]) + + } else { + l = fmt.Sprintf("%svarx%s.(%s)%s", l[:start-1], l[start:end], typ, l[end:]) + } + match = variableRe.FindAllStringSubmatchIndex(l, 1) + } + l = strings.ReplaceAll(l, "varx", "$") + return l + } + + //castReturn := func(l string, typ string) string { + // return strings.ReplaceAll(l, "$$", "$$.("+typ+")") + //} + + //printDef := func(d *def) { + // defNames = append(defNames, d.name) + // defs[d.name] = d + // if _, ok := funcExprsMap[d.name]; !ok { + // funcExprsMap[d.name] = "[]byte" + // } + // + // fmt.Println(outFile, d.name+":") + // for _, r := range d.rules.flat { + // r.fields = strings.Fields(r.name) + // typs := varToType(r.fields) + // for _, l := range r.body { + // l = castVarTypes(l, typs) + // fmt.Println(outFile, l) + // } + // } + //} + + //addDef := func(d *def) { + // defs[d.name] = d + // defNames = append(defNames, d.name) + //} + + var ruleStart bool = false + + for !ruleStart && sc.Scan() { + line := sc.Text() + + switch line { + case "%union {": + fmt.Fprintln(outFile, line) + fmt.Fprintln(outFile, " val interface{}") + fmt.Fprintln(outFile, " bytes []byte") + for sc.Scan() { + line := sc.Text() + if line == "}" { + fmt.Fprintln(outFile, line) + break + } + parts := strings.Fields(line) + if len(parts) != 2 { + return + } + gt := goType{name: parts[0], typ: parts[1]} + goTypesMap[gt.name] = gt.typ + goTypes = append(goTypes, gt) + //fmt.Fprintln(outFile, line) + } + continue + case "%{": + fmt.Fprintln(outFile, line) + for sc.Scan() { + line := sc.Text() + fmt.Fprintln(outFile, line) + if line == "%}" { + break + } + } + continue + case "%%": + ruleStart = true + default: + } + + if strings.HasPrefix(line, "%type") { + yaccTyp, err := parseYaccType(line) + if err != nil { + return err + } + for _, t := range yaccTyp { + funcExprsMap[t.name] = goTypesMap[t.typ] + } + yaccTypes = append(yaccTypes, yaccTyp...) + line = replaceTypeWithVal(line) + } + fmt.Fprintln(outFile, line) + } + + // rules + + var r *rule + var d *def + + for sc.Scan() { + line := sc.Text() + if line == "" { + fmt.Fprintln(outFile, line) + continue + } + if strings.HasSuffix(line, ":") && !strings.HasPrefix(strings.TrimSpace(line), "case ") { + r = nil + d = new(def) + d.name = line[:len(line)-1] + fmt.Println(d.name) + } else if r == nil { + if line == "{}" || line == "" || line == "{" || line == "/*empty*/" { + print() + } else { + r = new(rule) + r.name = parseRuleName(line) + r.fields = strings.Fields(r.name) + r.types = parseRuleTypes(r.fields, funcExprsMap) + } + } else if strings.HasPrefix(line, "|") { + r = new(rule) + r.name = parseRuleName(line) + r.fields = strings.Fields(r.name) + r.types = parseRuleTypes(r.fields, funcExprsMap) + } else { + // var replace + line = castVarTypes(line, r.types) + t, ok := funcExprsMap[d.name] + if !ok { + t = "[]byte" + } + line = strings.ReplaceAll(line, "$$.", "$$.("+t+").") + line = strings.ReplaceAll(line, "append($$,", "append($$.("+t+"),") + if strings.HasPrefix(t, "[]") || listTypes[t] { + line = strings.ReplaceAll(line, "$$ = nil", "$$ = "+t+"(nil)") + } else if strings.HasPrefix(t, "*") { + line = strings.ReplaceAll(line, "$$ = nil", "$$ = &"+t[1:]+"{}") + } else { + line = strings.ReplaceAll(line, "$$ = nil", "$$ = "+t+"(nil)") + } + } + + fmt.Fprintln(outFile, line) + } + + return nil +} + +var listTypes = map[string]bool{ + "Partitions": true, + "Columns": true, + "AssignmentExprs": true, + "Exprs": true, + "SelectExprs": true, + "Statements": true, + "Variables": true, + "TableExprs": true, + "TableNames": true, + "AliasedValues": true, + "SetVarExprs": true, + "PurgeBinaryLogs": true, +} + +var typeRe = regexp.MustCompile("<[a-zA-Z]+[0-9]*>") + +func replaceTypeWithVal(s string) string { + m := typeRe.FindStringIndex(s) + start := m[0] + end := m[1] + if s[start:end] == "" { + return s + } + return s[:start] + "" + s[end:] +} + +func parseRuleTypes(fields []string, funcExprsMap map[string]string) []string { + var typs []string + for _, f := range fields { + t, ok := funcExprsMap[f] + if !ok { + t = "[]byte" + } + typs = append(typs, t) + } + return typs +} diff --git a/go/vt/sqlparser/sql.go b/go/vt/sqlparser/sql.go index d0a9026b7c2..055ab2835c4 100755 --- a/go/vt/sqlparser/sql.go +++ b/go/vt/sqlparser/sql.go @@ -1,11 +1,11 @@ -// Code generated by goyacc -o sql.go sql.y. DO NOT EDIT. +// Code generated by goyacc -o sql.go sql3.y. DO NOT EDIT. -//line sql.y:18 +//line sql3.y:18 package sqlparser import __yyfmt__ "fmt" -//line sql.y:18 +//line sql3.y:18 import "fmt" import "strings" @@ -51,154 +51,11 @@ func yySpecialCommentMode(yylex interface{}) bool { return tkn.specialComment != nil } -//line sql.y:65 +//line sql3.y:65 type yySymType struct { - yys int - empty struct{} - statement Statement - selStmt SelectStatement - ddl *DDL - ddls []*DDL - ins *Insert - byt byte - bytes []byte - bytes2 [][]byte - str string - int int - strs []string - selectExprs SelectExprs - selectExpr SelectExpr - columns Columns - statements Statements - partitions Partitions - variables Variables - into *Into - colName *ColName - tableExprs TableExprs - tableExpr TableExpr - subquery *Subquery - simpleTableExpr SimpleTableExpr - joinCondition JoinCondition - triggerName TriggerName - tableName TableName - tableNames TableNames - procedureName ProcedureName - indexHints *IndexHints - asOf *AsOf - expr Expr - exprs Exprs - boolVal BoolVal - boolean bool - sqlVal *SQLVal - colTuple ColTuple - values Values - aliasedvalues AliasedValues - valTuple ValTuple - whens []*When - when *When - orderBy OrderBy - order *Order - limit *Limit - assignExprs AssignmentExprs - assignExpr *AssignmentExpr - setVarExprs SetVarExprs - setVarExpr *SetVarExpr - setScope SetScope - colIdent ColIdent - colIdents []ColIdent - tableIdent TableIdent - convertType *ConvertType - aliasedTableName *AliasedTableExpr - TableSpec *TableSpec - columnType ColumnType - queryOpts QueryOpts - JSONTableSpec *JSONTableSpec - JSONTableColDef *JSONTableColDef - JSONTableColOpts JSONTableColOpts - columnOrder *ColumnOrder - triggerOrder *TriggerOrder - colKeyOpt ColumnKeyOption - optVal Expr - LengthScaleOption LengthScaleOption - columnDefinition *ColumnDefinition - indexDefinition *IndexDefinition - indexInfo *IndexInfo - indexOption *IndexOption - indexOptions []*IndexOption - flushOption *FlushOption - purgeBinaryLogs *PurgeBinaryLogs - replicationOption *ReplicationOption - replicationOptions []*ReplicationOption - indexColumn *IndexColumn - indexColumns []*IndexColumn - constraintDefinition *ConstraintDefinition - constraintInfo ConstraintInfo - tableOption *TableOption - tableOptions []*TableOption - partOption *PartitionOption - subpart *SubPartition - ReferenceAction ReferenceAction - partDefs []*PartitionDefinition - partDef *PartitionDefinition - partSpec *PartitionSpec - partSpecs []*PartitionSpec - viewSpec *ViewSpec - viewCheckOption ViewCheckOption - showFilter *ShowFilter - frame *Frame - frameExtent *FrameExtent - frameBound *FrameBound - caseStatementCases []CaseStatementCase - caseStatementCase CaseStatementCase - ifStatementConditions []IfStatementCondition - ifStatementCondition IfStatementCondition - signalInfo SignalInfo - signalInfos []SignalInfo - signalConditionItemName SignalConditionItemName - declareHandlerAction DeclareHandlerAction - declareHandlerCondition DeclareHandlerCondition - declareHandlerConditions []DeclareHandlerCondition - procedureParam ProcedureParam - procedureParams []ProcedureParam - characteristic Characteristic - characteristics []Characteristic - charsetCollate *CharsetAndCollate - charsetCollates []*CharsetAndCollate - Fields *Fields - Lines *Lines - EnclosedBy *EnclosedBy - tableAndLockType *TableAndLockType - tableAndLockTypes TableAndLockTypes - lockType LockType - accountName AccountName - accountNames []AccountName - accountRenames []AccountRename - authentication *Authentication - accountWithAuth AccountWithAuth - accountsWithAuth []AccountWithAuth - tlsOptionItem TLSOptionItem - tlsOptionItems []TLSOptionItem - accountLimitItem AccountLimitItem - accountLimitItems []AccountLimitItem - passLockItem PassLockItem - passLockItems []PassLockItem - grantPrivilege Privilege - grantPrivileges []Privilege - grantObjectType GrantObjectType - privilegeLevel PrivilegeLevel - grantAssumption *GrantUserAssumption - with *With - window Window - over *Over - windowDef *WindowDef - eventName EventName - eventScheduleSpec *EventScheduleSpec - eventScheduleTimeSpec *EventScheduleTimeSpec - eventStatus EventStatus - eventOnCompletion EventOnCompletion - intervalExprs []IntervalExpr - separator Separator - srsAttr *SrsAttribute + yys int + val interface{} + bytes []byte } const STRING_TYPE_PREFIX_NON_KEYWORD = 57346 @@ -2420,6 +2277,7 @@ var yyAct = [...]int{ 3289, 4142, 25, 3802, 4136, 18, 4135, 17, 4134, 16, 104, 3148, 4137, 19, 4133, 15, 4127, 11, 4162, 39, 3428, 68, 3577, 4160, 37, 3588, 3158, 4159, 36, 4163, +<<<<<<< Updated upstream 40, 4158, 32, 4275, 3378, 4157, 31, 4156, 30, 4153, 27, 1, 3367, 4208, 3184, 668, 3185, 3186, 3306, 3187, 3188, 3307, 50, 3189, 1479, 1478, 1488, 1489, 1481, 1482, @@ -2463,6 +2321,51 @@ var yyAct = [...]int{ 667, 3684, 46, 2721, 1238, 3733, 1557, 1558, 1450, 3584, 3989, 111, 1590, 1591, 1592, 676, 3677, 675, 3554, 3633, 3634, 684, 3294, 1550, 1552, 1553, 3640, 29, 21, 1154, +======= + 40, 4158, 32, 4208, 3378, 4157, 31, 4156, 30, 4153, + 27, 668, 3367, 50, 3184, 2569, 3185, 3186, 3306, 3187, + 3188, 3307, 2110, 3189, 1479, 1478, 1488, 1489, 1481, 1482, + 1483, 1484, 1485, 1486, 1487, 1480, 4152, 26, 1490, 3198, + 3199, 3200, 3201, 4132, 14, 3345, 1479, 1478, 1488, 1489, + 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1480, 3423, 587, + 1490, 3704, 3430, 3431, 3432, 3382, 3703, 3333, 3710, 3437, + 3438, 3355, 3440, 3517, 4129, 13, 3387, 4128, 12, 3117, + 3392, 3384, 3119, 3358, 3396, 3397, 3458, 3399, 2946, 3463, + 3423, 3385, 4126, 10, 3400, 3424, 1479, 1478, 1488, 1489, + 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1480, 4203, 4070, + 1490, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, + 3221, 3222, 3720, 3415, 1711, 3489, 3549, 1691, 692, 3022, + 3425, 3901, 2870, 3108, 2618, 1178, 3408, 3409, 2506, 1293, + 3457, 4216, 3436, 3527, 4081, 4083, 3687, 3686, 3157, 2939, + 2938, 1287, 2556, 2090, 3583, 3449, 3025, 3451, 3026, 2520, + 3015, 4101, 3300, 2592, 3544, 2133, 2580, 1350, 3464, 2429, + 3467, 2434, 3469, 3471, 3473, 3475, 3196, 1479, 1478, 1488, + 1489, 1481, 1482, 1483, 1484, 1485, 1486, 1487, 1480, 3602, + 3849, 1490, 3622, 3343, 4004, 3621, 3620, 2833, 1142, 162, + 117, 108, 2535, 1220, 504, 2431, 2892, 3236, 1154, 4084, + 3596, 3598, 1290, 3238, 2891, 2909, 2156, 3530, 2446, 1376, + 3552, 3377, 3857, 2890, 2889, 4188, 2893, 1626, 1624, 1625, + 1623, 1628, 3532, 3533, 3534, 1627, 509, 1610, 4261, 3480, + 3481, 3591, 3597, 3661, 1460, 735, 3487, 135, 3058, 640, + 641, 124, 133, 511, 3498, 1498, 2716, 1415, 2823, 3512, + 3514, 3553, 1067, 1068, 3565, 1060, 1599, 1599, 4351, 2707, + 4095, 3560, 3978, 1551, 1551, 1551, 1556, 1556, 1556, 1559, + 1560, 1561, 1562, 1556, 1556, 1556, 4087, 3571, 3572, 3573, + 3574, 484, 3674, 4250, 3618, 3579, 1445, 3980, 1154, 162, + 3809, 2153, 3595, 3550, 2769, 3642, 3589, 3590, 1546, 630, + 630, 2331, 705, 3108, 630, 652, 3608, 3600, 3828, 3982, + 2241, 162, 719, 3460, 162, 718, 717, 714, 715, 630, + 630, 2366, 4232, 2230, 3599, 162, 3224, 3611, 3223, 484, + 484, 484, 484, 3612, 3614, 3615, 3616, 3617, 3226, 1472, + 3619, 3340, 1348, 694, 162, 162, 162, 162, 162, 1419, + 162, 3699, 3700, 3701, 1418, 3650, 3549, 3644, 1417, 3667, + 3383, 1416, 1410, 663, 2400, 162, 162, 2976, 1388, 1386, + 630, 1385, 1730, 1598, 2676, 2672, 162, 662, 667, 3735, + 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 46, + 2721, 3684, 1238, 1450, 3584, 3733, 1557, 1558, 3989, 111, + 676, 675, 1590, 1591, 1592, 684, 3677, 4275, 3554, 3633, + 3634, 3294, 1, 1550, 1552, 1553, 3640, 29, 21, 1154, +>>>>>>> Stashed changes 20, 1196, 3748, 3749, 3648, 2609, 2629, 3698, 3702, 1176, 3656, 3658, 630, 630, 630, 48, 54, 1154, 53, 3737, 51, 3580, 3581, 3582, 3739, 3423, 52, 3561, 3562, 3563, @@ -10602,6 +10505,7 @@ var yyPgo = [...]int{ 195, 223, 3510, 4, 3504, 3503, 14, 199, 3502, 3500, 71, 3026, 3496, 3490, 3488, 3486, 3485, 3479, 146, 3476, 3475, 3024, 3471, 3022, 3470, 3018, 3016, 3014, 3011, 3008, +<<<<<<< Updated upstream 222, 3468, 3006, 3003, 3001, 3467, 2664, 225, 443, 221, 3462, 139, 1801, 3461, 219, 3457, 205, 3455, 3451, 3450, 431, 3449, 161, 3448, 378, 162, 167, 164, 444, 3444, @@ -10640,62 +10544,103 @@ var yyPgo = [...]int{ 3101, 211, 176, 77, 101, 3099, 79, 109, 3062, 94, 3055, 15, 70, 3053, 23, 25, 202, 3051, 0, 145, 201, 3043, 150, 3031, 3020, 217, 2992, +======= + 222, 3468, 3006, 3003, 3001, 3467, 3462, 2664, 225, 443, + 221, 3461, 139, 201, 3457, 1801, 3455, 219, 3451, 205, + 3450, 3449, 3448, 431, 3444, 161, 3443, 378, 162, 167, + 164, 444, 3442, 68, 160, 312, 3440, 8, 3439, 113, + 3428, 213, 3427, 218, 2799, 190, 178, 189, 3425, 3424, + 174, 3423, 3422, 3421, 212, 3419, 3418, 231, 304, 3417, + 3414, 185, 3413, 133, 3412, 173, 3411, 3408, 3404, 3399, + 227, 121, 80, 166, 148, 3393, 159, 3392, 3391, 3389, + 3388, 3378, 3376, 92, 26, 300, 3373, 152, 192, 3372, + 54, 44, 42, 3371, 3368, 53, 3367, 3366, 129, 3365, + 3362, 130, 3360, 186, 76, 3359, 3358, 3356, 3355, 111, + 81, 3352, 21, 3351, 183, 3348, 3344, 3343, 3340, 3337, + 93, 3336, 98, 3333, 187, 206, 351, 3326, 3312, 50, + 51, 3310, 63, 18, 19, 107, 28, 114, 82, 177, + 165, 128, 153, 64, 142, 60, 154, 143, 3309, 226, + 179, 208, 117, 24, 3308, 3305, 196, 3303, 115, 204, + 181, 182, 203, 3302, 3298, 3296, 235, 3295, 171, 558, + 3293, 126, 288, 232, 3292, 238, 144, 3291, 3290, 3289, + 3288, 116, 55, 122, 3287, 36, 233, 230, 234, 46, + 87, 3285, 2179, 5390, 5586, 7169, 27, 74, 69, 5651, + 112, 207, 3284, 83, 3281, 3278, 3277, 4837, 184, 65, + 58, 156, 3276, 155, 49, 106, 3275, 3271, 3270, 3269, + 3268, 3267, 191, 330, 3266, 3265, 73, 3264, 3263, 43, + 20, 17, 16, 3262, 157, 215, 214, 209, 3259, 200, + 61, 3258, 3255, 180, 132, 3254, 3252, 3249, 3246, 175, + 124, 198, 3245, 197, 125, 169, 3244, 120, 3243, 3242, + 110, 4864, 147, 3240, 3238, 661, 131, 3237, 3236, 3235, + 3234, 56, 3232, 3230, 3, 3211, 108, 72, 52, 118, + 35, 158, 3209, 3207, 193, 3206, 3205, 141, 170, 3203, + 140, 135, 59, 3201, 78, 151, 3200, 163, 2, 9, + 6, 3199, 3198, 3196, 3193, 3192, 3191, 3190, 3189, 127, + 3187, 3186, 105, 88, 95, 3185, 62, 3184, 3181, 3179, + 194, 168, 86, 220, 136, 11, 3178, 3175, 10, 3171, + 172, 3164, 100, 3162, 123, 3149, 3148, 75, 104, 47, + 99, 3128, 3123, 102, 3111, 3108, 103, 3106, 3101, 224, + 2403, 3099, 526, 3062, 211, 176, 77, 101, 3055, 79, + 109, 3053, 94, 3051, 15, 70, 3043, 23, 25, 202, + 0, 145, 150, 3031, 3020, 217, 2992, +>>>>>>> Stashed changes } var yyR1 = [...]int{ - 0, 457, 457, 1, 1, 1, 1, 1, 1, 1, + 0, 96, 96, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 241, 241, 95, 4, 4, 10, 10, 9, + 1, 1, 244, 244, 95, 4, 4, 10, 10, 9, 15, 6, 6, 11, 11, 11, 12, 12, 7, 7, - 13, 13, 14, 14, 5, 5, 124, 124, 8, 8, - 123, 123, 123, 238, 238, 238, 238, 235, 235, 125, - 125, 122, 122, 130, 16, 16, 16, 108, 108, 17, - 18, 18, 18, 18, 460, 460, 139, 139, 137, 137, - 138, 138, 233, 233, 19, 19, 19, 243, 243, 248, - 248, 248, 251, 251, 251, 251, 221, 222, 223, 21, + 13, 13, 14, 14, 5, 5, 127, 127, 8, 8, + 126, 126, 126, 241, 241, 241, 241, 238, 238, 128, + 128, 125, 125, 133, 16, 16, 16, 111, 111, 17, + 18, 18, 18, 18, 103, 103, 142, 142, 140, 140, + 141, 141, 236, 236, 19, 19, 19, 246, 246, 251, + 251, 251, 254, 254, 254, 254, 224, 225, 226, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, - 21, 21, 21, 21, 448, 448, 448, 449, 449, 449, - 449, 449, 276, 276, 276, 276, 413, 413, 428, 428, - 428, 429, 429, 427, 427, 427, 427, 427, 431, 431, - 432, 432, 430, 430, 430, 430, 434, 434, 435, 435, - 433, 433, 433, 433, 433, 433, 433, 433, 433, 433, - 433, 433, 433, 433, 416, 416, 416, 50, 50, 50, - 50, 50, 51, 51, 51, 51, 51, 51, 436, 436, - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, + 21, 21, 21, 21, 451, 451, 451, 452, 452, 452, + 452, 452, 279, 279, 279, 279, 416, 416, 431, 431, + 431, 432, 432, 430, 430, 430, 430, 430, 434, 434, + 435, 435, 433, 433, 433, 433, 437, 437, 438, 438, 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, - 436, 436, 436, 436, 436, 436, 436, 436, 436, 436, - 436, 437, 437, 438, 438, 438, 438, 438, 438, 438, - 438, 438, 438, 438, 438, 438, 438, 438, 438, 438, - 438, 438, 438, 438, 438, 438, 438, 438, 438, 438, - 438, 438, 438, 438, 438, 438, 438, 438, 438, 438, - 438, 438, 439, 439, 440, 440, 441, 441, 441, 441, - 442, 442, 442, 442, 442, 443, 443, 443, 443, 443, - 443, 443, 444, 444, 445, 445, 3, 2, 394, 394, - 395, 395, 396, 396, 396, 396, 397, 397, 398, 398, - 399, 399, 399, 399, 399, 399, 399, 399, 399, 399, - 31, 31, 31, 31, 31, 31, 275, 275, 271, 271, - 271, 273, 273, 274, 274, 274, 415, 415, 415, 409, - 409, 409, 411, 411, 410, 410, 410, 412, 412, 417, - 417, 417, 417, 417, 419, 419, 419, 419, 419, 419, - 419, 420, 420, 420, 418, 418, 158, 158, 421, 421, - 426, 426, 422, 422, 423, 423, 425, 425, 425, 424, - 424, 424, 424, 313, 313, 177, 177, 68, 68, 69, - 69, 69, 210, 210, 210, 20, 20, 20, 20, 20, + 436, 436, 436, 436, 419, 419, 419, 50, 50, 50, + 50, 50, 51, 51, 51, 51, 51, 51, 439, 439, + 439, 439, 439, 439, 439, 439, 439, 439, 439, 439, + 439, 439, 439, 439, 439, 439, 439, 439, 439, 439, + 439, 439, 439, 439, 439, 439, 439, 439, 439, 439, + 439, 440, 440, 441, 441, 441, 441, 441, 441, 441, + 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, + 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, + 441, 441, 441, 441, 441, 441, 441, 441, 441, 441, + 441, 441, 442, 442, 443, 443, 444, 444, 444, 444, + 445, 445, 445, 445, 445, 446, 446, 446, 446, 446, + 446, 446, 447, 447, 448, 448, 3, 2, 397, 397, + 398, 398, 399, 399, 399, 399, 400, 400, 401, 401, + 402, 402, 402, 402, 402, 402, 402, 402, 402, 402, + 31, 31, 31, 31, 31, 31, 278, 278, 274, 274, + 274, 276, 276, 277, 277, 277, 418, 418, 418, 412, + 412, 412, 414, 414, 413, 413, 413, 415, 415, 420, + 420, 420, 420, 420, 422, 422, 422, 422, 422, 422, + 422, 423, 423, 423, 421, 421, 161, 161, 424, 424, + 429, 429, 425, 425, 426, 426, 428, 428, 428, 427, + 427, 427, 427, 316, 316, 180, 180, 68, 68, 69, + 69, 69, 213, 213, 213, 20, 20, 20, 20, 20, 20, 26, 26, 28, 28, 28, 28, 55, 55, 56, 29, 29, 29, 29, 57, 57, 58, 32, 32, 32, 32, 32, 32, 65, 65, 65, 64, 64, 63, 63, - 63, 63, 63, 63, 34, 35, 36, 461, 461, 461, + 63, 63, 63, 63, 34, 35, 36, 104, 104, 104, 59, 59, 37, 37, 37, 40, 40, 40, 41, 41, 41, 38, 39, 42, 30, 30, 30, 30, 66, 66, 61, 61, 60, 60, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 62, 33, 33, 33, 33, - 33, 33, 25, 393, 393, 393, 54, 54, 27, 27, + 33, 33, 25, 396, 396, 396, 54, 54, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +<<<<<<< Updated upstream 27, 76, 76, 350, 351, 351, 351, 351, 351, 351, 337, 337, 338, 338, 338, 338, 338, 338, 327, 327, 327, 302, 302, 302, 302, 302, 302, 302, 302, 302, @@ -10734,6 +10679,46 @@ var yyR1 = [...]int{ 355, 355, 356, 356, 358, 358, 272, 272, 359, 359, 360, 360, 357, 357, 357, 361, 361, 390, 390, 390, 389, 389, 71, 71, 71, 71, 73, 73, 72, 72, +======= + 27, 76, 76, 353, 354, 354, 354, 354, 354, 354, + 340, 340, 341, 341, 341, 341, 341, 341, 330, 330, + 330, 305, 305, 305, 305, 305, 305, 305, 305, 305, + 305, 305, 305, 305, 305, 305, 305, 305, 304, 304, + 304, 304, 308, 308, 306, 306, 306, 306, 306, 306, + 306, 306, 306, 306, 306, 306, 306, 306, 306, 307, + 307, 307, 307, 307, 307, 307, 307, 309, 309, 309, + 309, 309, 310, 310, 310, 310, 310, 310, 310, 310, + 310, 310, 310, 310, 310, 310, 310, 310, 310, 310, + 310, 310, 310, 310, 310, 310, 310, 310, 311, 311, + 311, 311, 311, 311, 311, 311, 339, 339, 313, 313, + 312, 312, 312, 333, 333, 334, 334, 334, 331, 331, + 331, 332, 332, 317, 317, 317, 317, 317, 317, 318, + 335, 319, 319, 320, 320, 320, 320, 321, 321, 322, + 322, 322, 324, 324, 329, 329, 328, 328, 328, 328, + 328, 328, 325, 325, 325, 325, 325, 325, 326, 326, + 326, 327, 338, 338, 338, 338, 338, 314, 46, 46, + 52, 373, 373, 373, 373, 373, 373, 373, 373, 373, + 373, 373, 373, 373, 373, 374, 374, 379, 379, 268, + 268, 269, 269, 53, 53, 53, 53, 53, 167, 167, + 375, 375, 377, 377, 377, 377, 377, 377, 377, 376, + 376, 378, 378, 342, 342, 370, 370, 369, 369, 368, + 368, 368, 368, 368, 368, 368, 351, 351, 352, 352, + 365, 365, 365, 365, 365, 365, 365, 365, 346, 346, + 346, 345, 345, 347, 347, 350, 350, 350, 367, 367, + 366, 366, 343, 343, 343, 380, 380, 380, 380, 380, + 101, 101, 344, 344, 344, 381, 348, 348, 349, 349, + 349, 389, 390, 388, 388, 388, 388, 388, 168, 168, + 168, 372, 372, 372, 371, 371, 371, 371, 371, 371, + 371, 371, 371, 371, 371, 371, 371, 371, 371, 371, + 371, 371, 371, 371, 371, 371, 371, 371, 371, 371, + 371, 371, 371, 371, 371, 371, 371, 371, 371, 371, + 371, 371, 371, 102, 102, 102, 323, 323, 355, 355, + 355, 355, 355, 459, 459, 459, 356, 356, 356, 356, + 356, 356, 450, 450, 449, 449, 449, 357, 357, 358, + 358, 358, 359, 359, 361, 361, 275, 275, 362, 362, + 363, 363, 360, 360, 360, 364, 364, 393, 393, 393, + 392, 392, 71, 71, 71, 71, 73, 73, 72, 72, +>>>>>>> Stashed changes 80, 80, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, 78, @@ -10742,6 +10727,7 @@ var yyR1 = [...]int{ 78, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, +<<<<<<< Updated upstream 79, 79, 79, 79, 79, 79, 70, 70, 285, 285, 75, 209, 209, 209, 270, 270, 383, 383, 384, 384, 382, 382, 382, 382, 382, 382, 382, 382, 382, 382, @@ -10751,11 +10737,23 @@ var yyR1 = [...]int{ 23, 23, 23, 23, 23, 23, 23, 23, 23, 388, 388, 388, 24, 24, 81, 82, 82, 82, 284, 284, 284, 284, 85, 85, 85, 85, 236, 236, 237, 237, +======= + 79, 79, 79, 79, 79, 79, 70, 70, 288, 288, + 75, 212, 212, 212, 273, 273, 386, 386, 387, 387, + 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, + 385, 385, 385, 385, 385, 385, 385, 385, 385, 385, + 385, 383, 383, 382, 382, 384, 384, 74, 74, 74, + 74, 162, 162, 22, 22, 77, 77, 417, 417, 23, + 23, 23, 23, 23, 23, 23, 23, 23, 23, 391, + 391, 391, 24, 24, 81, 82, 82, 82, 287, 287, + 287, 287, 85, 85, 85, 85, 239, 239, 240, 240, +>>>>>>> Stashed changes 86, 86, 86, 86, 87, 87, 87, 87, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, 83, +<<<<<<< Updated upstream 119, 257, 257, 256, 256, 255, 255, 255, 258, 258, 258, 258, 299, 299, 299, 84, 84, 84, 96, 96, 91, 91, 94, 94, 94, 97, 97, 98, 98, 99, @@ -10914,6 +10912,166 @@ var yyR1 = [...]int{ 282, 282, 282, 282, 283, 283, 283, 283, 283, 283, 280, 280, 280, 280, 280, 280, 281, 281, 281, 458, 459, +======= + 122, 260, 260, 259, 259, 258, 258, 258, 261, 261, + 261, 261, 302, 302, 302, 84, 84, 84, 97, 97, + 91, 91, 94, 94, 94, 98, 98, 99, 99, 100, + 100, 92, 93, 43, 44, 44, 44, 44, 45, 89, + 89, 89, 90, 90, 90, 90, 113, 113, 463, 463, + 463, 88, 464, 105, 106, 106, 108, 108, 108, 109, + 109, 109, 110, 110, 110, 265, 265, 265, 265, 265, + 265, 265, 107, 107, 107, 116, 116, 120, 120, 120, + 120, 119, 119, 119, 119, 215, 215, 220, 294, 294, + 196, 196, 216, 216, 221, 221, 221, 222, 222, 223, + 223, 223, 223, 223, 218, 218, 217, 217, 219, 183, + 183, 183, 183, 181, 181, 181, 181, 181, 181, 182, + 182, 182, 182, 182, 182, 182, 182, 182, 182, 182, + 182, 182, 182, 182, 179, 179, 292, 292, 292, 292, + 291, 291, 291, 124, 124, 129, 129, 131, 131, 131, + 131, 131, 131, 131, 131, 134, 198, 198, 465, 465, + 152, 152, 153, 153, 153, 153, 154, 154, 154, 154, + 154, 156, 156, 156, 157, 157, 157, 157, 157, 157, + 158, 159, 159, 155, 155, 155, 177, 177, 234, 234, + 235, 235, 233, 233, 237, 237, 130, 130, 132, 132, + 132, 132, 137, 137, 138, 138, 139, 139, 299, 299, + 143, 143, 143, 145, 144, 144, 144, 144, 144, 144, + 146, 146, 453, 454, 454, 455, 455, 455, 455, 456, + 456, 456, 456, 456, 456, 456, 456, 456, 456, 457, + 457, 458, 458, 147, 147, 149, 150, 150, 148, 148, + 148, 148, 148, 148, 160, 160, 151, 163, 163, 163, + 163, 164, 164, 121, 121, 121, 121, 121, 121, 121, + 121, 257, 257, 166, 166, 165, 165, 165, 165, 165, + 165, 165, 165, 165, 165, 192, 192, 192, 192, 192, + 192, 169, 169, 169, 169, 169, 169, 169, 115, 115, + 193, 193, 193, 136, 135, 135, 118, 118, 117, 117, + 194, 194, 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, 175, 175, + 175, 175, 175, 175, 175, 175, 175, 175, 186, 186, + 190, 190, 190, 190, 190, 190, 190, 190, 190, 190, + 190, 190, 190, 190, 190, 190, 190, 189, 189, 189, + 189, 189, 189, 189, 189, 189, 189, 189, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 184, 184, 184, + 184, 184, 184, 184, 184, 184, 184, 185, 185, 185, + 185, 185, 185, 185, 185, 185, 185, 185, 191, 191, + 191, 191, 191, 462, 462, 188, 188, 187, 187, 187, + 187, 187, 187, 112, 112, 112, 112, 112, 300, 300, + 300, 301, 301, 301, 301, 301, 301, 301, 301, 301, + 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, + 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, + 301, 301, 301, 301, 301, 301, 301, 301, 301, 301, + 301, 301, 301, 303, 303, 303, 303, 303, 303, 303, + 303, 303, 303, 303, 303, 303, 303, 303, 303, 303, + 303, 303, 303, 67, 67, 205, 205, 114, 114, 203, + 203, 204, 206, 206, 202, 202, 202, 202, 202, 202, + 202, 202, 202, 202, 202, 202, 202, 202, 202, 174, + 174, 174, 174, 174, 174, 174, 174, 174, 174, 174, + 176, 176, 176, 207, 207, 195, 195, 123, 208, 208, + 209, 210, 210, 211, 211, 214, 227, 227, 227, 228, + 228, 228, 228, 178, 178, 178, 229, 229, 229, 229, + 171, 171, 170, 170, 170, 172, 172, 172, 172, 173, + 173, 466, 466, 232, 232, 231, 231, 230, 230, 230, + 230, 230, 230, 242, 242, 197, 197, 200, 200, 199, + 201, 243, 243, 248, 248, 248, 248, 245, 245, 249, + 249, 249, 249, 252, 252, 253, 253, 253, 250, 250, + 250, 250, 247, 247, 247, 296, 296, 296, 255, 255, + 264, 264, 262, 262, 263, 263, 256, 256, 315, 315, + 315, 270, 270, 271, 271, 272, 272, 266, 266, 266, + 267, 267, 293, 293, 289, 289, 295, 295, 290, 290, + 297, 297, 298, 298, 298, 298, 394, 394, 395, 395, + 395, 336, 336, 405, 405, 337, 337, 406, 406, 408, + 408, 403, 403, 404, 404, 407, 407, 47, 409, 409, + 410, 410, 411, 411, 411, 411, 48, 49, 49, 49, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 280, 280, 280, + 280, 280, 280, 280, 280, 280, 280, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 281, 281, 281, 281, 281, + 281, 281, 281, 281, 281, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 282, 282, 282, 282, 282, 282, 282, 282, + 282, 282, 285, 285, 285, 285, 285, 285, 285, 285, + 285, 285, 285, 285, 285, 285, 285, 285, 285, 285, + 285, 285, 285, 285, 286, 286, 286, 286, 286, 286, + 283, 283, 283, 283, 283, 283, 284, 284, 284, 460, + 461, +>>>>>>> Stashed changes } var yyR2 = [...]int{ @@ -11191,16 +11349,22 @@ var yyR2 = [...]int{ } var yyChk = [...]int{ - -1000, -457, -1, -4, -10, -15, -16, -17, -18, -19, + -1000, -96, -1, -4, -10, -15, -16, -17, -18, -19, -21, -71, -22, -23, -24, -81, -85, -86, -87, -83, -84, -91, -92, -93, -89, -88, -30, -33, -25, -95, -43, -44, -45, -47, -48, -49, -50, -51, -53, -52, +<<<<<<< Updated upstream -46, -5, 11, -131, -458, 12, -125, 34, -76, 190, -448, -73, -72, -74, -75, 193, 192, 229, 194, 629, +======= + -46, -5, 11, -134, -460, 12, -128, 34, -76, 190, + -451, -73, -72, -74, -75, 193, 192, 229, 194, 629, +>>>>>>> Stashed changes 366, 630, 222, 72, 440, -94, 443, 444, -463, 304, 305, 25, 42, 445, 447, 35, 36, 244, 332, 334, 197, 441, 426, 427, 357, 677, -6, 635, 55, 76, 191, 224, 223, 31, -8, -11, 199, -12, -13, -7, +<<<<<<< Updated upstream 746, -207, 20, -102, -464, -207, -10, -9, -4, 635, -102, -108, 14, 15, 13, 549, -102, -350, 28, -3, 117, 76, -8, 11, -264, -275, 97, 540, 198, -273, @@ -11208,6 +11372,15 @@ var yyChk = [...]int{ 265, 199, 328, 199, 200, 202, 540, 198, 237, 236, 328, 330, 269, 629, 199, -145, -294, -280, -282, -281, 346, 82, -279, 569, 573, 269, 576, 577, 582, 336, +======= + 746, -210, 20, -105, -464, -210, -10, -9, -4, 635, + -105, -111, 14, 15, 13, 549, -105, -353, 28, -3, + 117, 76, -8, 11, -267, -278, 97, 540, 198, -276, + 328, 330, 208, -264, -266, -274, 254, 264, 49, 209, + 265, 199, 328, 199, 200, 202, 540, 198, 237, 236, + 328, 330, 269, 629, 199, -148, -297, -283, -285, -284, + 346, 82, -282, 569, 573, 269, 576, 577, 582, 336, +>>>>>>> Stashed changes 90, 52, 366, 563, 358, 367, 219, 518, 564, 329, 335, 338, 359, 718, 368, 370, 371, 561, 562, 54, 202, 551, 552, 555, 212, 733, 351, 220, 632, 265, @@ -11239,6 +11412,7 @@ var yyChk = [...]int{ 301, 264, 267, 484, 235, 728, 729, 471, 472, 442, 238, 229, 121, 535, 324, 684, 328, 381, 286, 59, 241, 53, 730, 731, 268, 242, 643, 285, 446, 342, +<<<<<<< Updated upstream 646, 199, 82, -284, -279, -282, -283, -280, 346, 230, 58, 95, 63, 62, 82, -279, 629, 143, 477, 525, 190, 515, 516, 522, -343, 523, 236, 423, 239, -299, @@ -11250,10 +11424,24 @@ var yyChk = [...]int{ -437, -412, 361, -436, -410, 191, 190, 15, 192, 269, 366, 367, 332, 200, 13, 35, 718, 217, 368, 369, 11, 222, 370, 371, 237, 14, 372, -438, -415, 384, +======= + 646, 199, 82, -287, -282, -285, -286, -283, 346, 230, + 58, 95, 63, 62, 82, -282, 629, 143, 477, 525, + 190, 515, 516, 522, -346, 523, 236, 423, 239, -302, + 199, -260, 238, 514, 333, 352, 573, 242, 243, 270, + 424, 430, 200, 201, 37, 527, 526, 518, -297, -97, + 446, -97, -97, 203, 446, -113, 231, 194, -148, 230, + -66, 82, 306, -66, 34, 82, -160, -289, -297, 82, + -282, 41, 82, 445, 517, 517, 84, 636, 245, 26, + -440, -415, 361, -439, -413, 191, 190, 15, 192, 269, + 366, 367, 332, 200, 13, 35, 718, 217, 368, 369, + 11, 222, 370, 371, 237, 14, 372, -441, -418, 384, +>>>>>>> Stashed changes 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417, 418, 419, 420, 421, 422, 81, 82, +<<<<<<< Updated upstream -279, 26, -437, -412, 361, 369, 423, 442, 423, 423, -266, -265, 382, 503, 143, -124, 688, -122, -130, -296, -294, -280, -195, -465, 250, 540, -253, 328, -273, 204, @@ -11266,12 +11454,30 @@ var yyChk = [...]int{ 225, 471, 472, 81, 83, 91, 84, 85, 86, 87, 92, 93, 94, -286, -282, -278, -281, 569, 573, 576, 577, 582, -196, -458, 144, 145, 146, 147, 148, 149, +======= + -282, 26, -440, -415, 361, 369, 423, 442, 423, 423, + -269, -268, 382, 503, 143, -127, 688, -125, -133, -299, + -297, -283, -198, -465, 250, 540, -256, 328, -276, 204, + -129, -131, -132, -152, -135, 686, -460, -130, -453, -148, + -136, 82, 598, -109, 10, -108, -110, 9, 8, -109, + -228, 22, 21, -265, -106, -228, -461, 78, -461, -127, + -119, 134, -121, -297, -165, 100, -175, 33, 29, -174, + 346, 230, -166, -202, -283, -201, -136, 143, -301, 132, + 133, 140, 101, 186, -186, -184, -185, -187, -189, -190, + 225, 471, 472, 81, 83, 91, 84, 85, 86, 87, + 92, 93, 94, -289, -285, -281, -284, 569, 573, 576, + 577, 582, -199, -460, 144, 145, 146, 147, 148, 149, +>>>>>>> Stashed changes 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 66, 67, 567, 198, 550, 551, 474, 552, 13, 553, 554, 555, 631, 219, +<<<<<<< Updated upstream 559, 103, 55, 323, 541, 542, 546, -188, 543, 547, +======= + 559, 103, 55, 323, 541, 542, 546, -191, 543, 547, +>>>>>>> Stashed changes 548, 561, 562, 563, 564, 205, 540, 138, 549, 586, 587, 588, 589, 590, 591, 592, 593, 595, 596, 594, 570, 571, 572, 574, 575, 578, 579, 580, 581, 583, @@ -11296,15 +11502,22 @@ var yyChk = [...]int{ 683, 341, 48, 742, 659, 199, 44, 105, 490, 450, 485, 203, 557, 237, 312, 9, 49, 36, 511, 14, 372, 72, 75, 478, 475, 483, 482, 743, 17, 325, +<<<<<<< Updated upstream 566, 635, 531, 98, 657, 512, 539, -102, -102, -102, -242, 442, -249, -246, 526, 527, -247, -250, -244, -199, 503, 715, 716, 525, 477, 524, -286, -294, -280, 346, +======= + 566, 635, 531, 98, 657, 512, 539, -105, -105, -105, + -245, 442, -252, -249, 526, 527, -250, -253, -247, -202, + 503, 715, 716, 525, 477, 524, -289, -297, -283, 346, +>>>>>>> Stashed changes 230, 143, 570, 571, 572, 103, 474, 550, 586, 541, 543, 538, 542, 540, 33, 587, 29, 94, 588, 567, 205, 13, 186, 574, 575, 589, 590, 591, 66, 544, 545, 631, 138, 100, 592, 593, 92, 595, 596, 323, 549, 67, 594, 198, 580, 579, 578, 581, 553, 554, 93, 546, 547, 548, 55, 584, 583, 585, -2, -6, +<<<<<<< Updated upstream -458, -145, -351, -338, -341, -286, -280, -282, -283, 226, -281, 214, -378, 82, -279, 211, -207, -102, 200, 202, 549, -260, 205, -260, 237, 236, 269, -274, 262, -260, @@ -11354,11 +11567,63 @@ var yyChk = [...]int{ -148, -294, 77, -243, -248, 528, 530, 442, -247, -247, -293, -286, 81, 33, -349, 109, 120, 34, 187, -207, 78, 77, -301, -305, -307, -306, -308, -303, -304, -67, +======= + -460, -148, -354, -341, -344, -289, -283, -285, -286, 226, + -284, 214, -381, 82, -282, 211, -210, -105, 200, 202, + 549, -263, 205, -263, 237, 236, 269, -277, 262, -263, + -263, 719, 199, -276, 109, 109, -77, -148, -417, -412, + -418, -262, 205, -289, -262, -262, -262, -262, -262, -262, + -262, -262, 82, -287, -148, 187, -82, -148, -140, 16, + 16, 75, 75, 82, -287, 82, 429, 373, 34, -261, + 117, 17, 540, 198, 199, 236, 237, 202, 269, -261, + -348, 16, 119, 240, 240, 240, 240, 241, 240, -259, + 517, 519, 520, 521, -258, 16, 119, 17, -122, 117, + 24, -460, -228, -228, -258, 240, 135, -99, 99, -99, + 82, 445, 203, -90, -4, -18, -16, -17, -113, -9, + -177, -155, 28, 6, 7, 109, 34, 34, 81, 59, + 34, -61, -60, -62, 292, 293, 294, 295, 296, 297, + 298, 299, 300, 301, 302, 303, 34, -396, 76, 187, + -336, 503, 82, -409, -410, -148, 84, 84, 74, 352, + 74, 77, 203, 77, 74, -442, 362, 76, -442, 330, + 362, 363, 264, 328, 202, -442, -442, 330, -442, -442, + -442, 349, -442, -442, 517, -442, -442, -442, 364, 365, + -442, 515, 202, -442, -442, -442, -442, -442, 79, 74, + 77, 352, 74, 16, 74, 425, 428, 530, -167, 26, + -373, 143, 374, 375, 376, 377, 373, 352, 378, 379, + 380, 240, 381, 199, 517, 373, -6, -125, 77, -232, + -460, 77, -199, -460, 82, -329, -328, -325, -326, -327, + -324, 33, 199, -262, 269, -143, -145, -144, -146, 64, + 68, 70, 65, 66, 67, 518, 71, -272, 28, -135, + -460, -124, -9, -134, -129, -460, -153, 122, -163, -272, + -154, 72, 204, 73, 28, -155, -156, -157, -158, -159, + 6, 7, 54, -460, -460, -7, -8, 26, 27, -14, + -7, -12, -14, 26, 27, 26, 27, -7, -229, 24, + 35, -178, 84, 87, -202, -211, -214, -121, -297, 58, + -116, 26, 27, 65, 57, 63, 62, -225, 89, 16, + -292, 99, 97, 98, 116, -291, 28, 82, 81, -287, + 187, -121, -169, 119, 100, 117, 118, 102, 129, 128, + 139, 132, 133, 134, 135, 136, 137, 138, 130, 131, + 142, 109, 110, 111, 112, 113, 114, 115, -257, -460, + -136, -460, 187, -460, 187, 188, 189, 187, -175, -175, + -175, -175, -175, -175, -175, 81, 81, 81, -460, 187, + 187, -460, -460, -460, -460, -460, -194, -121, 635, -460, + 199, -460, -460, -460, -460, -460, -460, -460, -460, -460, + -460, -460, -460, -460, -460, -460, -205, -121, -460, -460, + -462, -460, -462, -462, -188, -462, -460, -188, -188, -460, + -460, -460, -460, -460, -460, -460, -460, -460, -460, -460, + -460, -460, -460, -460, -460, -460, -460, -460, -460, -460, + -460, -460, -460, -460, -460, -460, -460, -460, -460, -460, + -188, -188, -188, -460, -256, -256, 16, -140, -141, -148, + -151, -297, 77, -246, -251, 528, 530, 442, -250, -250, + -296, -289, 81, 33, -352, 109, 120, 34, 187, -210, + 78, 77, -304, -308, -310, -309, -311, -306, -307, -67, +>>>>>>> Stashed changes 481, 479, 475, 474, 477, 480, 143, 478, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 34, 225, 471, 472, 473, 646, 495, 496, 497, 498, 499, 500, 501, 502, 449, 476, 633, 450, 451, 452, 453, 454, 455, 457, 458, 459, 460, 461, 462, 463, 464, +<<<<<<< Updated upstream 465, 466, 467, 468, 469, -301, -301, -301, -301, -301, -285, -378, 82, -284, 76, -225, -262, -286, -145, -275, 208, -273, 82, 100, 82, -144, -286, -294, -157, -260, @@ -11366,6 +11631,15 @@ var yyChk = [...]int{ 266, 267, 77, 203, 77, 203, 79, -137, 29, 74, -139, -145, 82, 82, -144, -157, -411, -409, -412, -158, -286, -294, -295, -294, -277, -282, -283, 660, 195, 26, +======= + 465, 466, 467, 468, 469, -304, -304, -304, -304, -304, + -288, -381, 82, -287, 76, -228, -265, -289, -148, -278, + 208, -276, 82, 100, 82, -147, -289, -297, -160, -263, + 263, -421, -420, -412, -415, 659, -263, -277, -412, 268, + 266, 267, 77, 203, 77, 203, 79, -140, 29, 74, + -142, -148, 82, 82, -147, -160, -414, -412, -415, -161, + -289, -297, -298, -297, -280, -285, -286, 660, 195, 26, +>>>>>>> Stashed changes 191, 194, 99, 28, 30, 661, 251, 102, 455, 143, 570, 571, 572, 489, 558, 21, 25, 213, 103, 197, 474, 477, 211, 142, 207, 214, 308, 310, 550, 586, @@ -11393,6 +11667,7 @@ var yyChk = [...]int{ 203, 557, 237, 93, 312, 9, 49, 36, 511, 14, 372, 72, 75, 546, 547, 548, 55, 478, 475, 483, 584, 482, 583, 585, 743, 104, 17, 325, 566, 635, +<<<<<<< Updated upstream 531, 98, 657, 512, 14, 192, 77, 81, -237, 82, -284, 81, -237, -236, -237, -236, 240, -258, 81, -298, -118, -260, -260, -145, -145, -145, -145, -145, -145, -258, @@ -11453,10 +11728,73 @@ var yyChk = [...]int{ 109, 109, -376, 24, -371, 635, -371, 81, -172, -132, -459, 77, 187, -196, 34, -348, -349, -348, -348, -80, -384, -78, -382, 195, 192, 191, 265, 197, -321, 550, +======= + 531, 98, 657, 512, 14, 192, 77, 81, -240, 82, + -287, 81, -240, -239, -240, -239, 240, -261, 81, -301, + -121, -263, -263, -148, -148, -148, -148, -148, -148, -261, + -261, -261, -261, -258, 16, -258, -261, -297, -297, -121, + -175, -412, 542, 134, -261, -297, -100, -98, 216, -98, + -100, 82, 82, 445, -90, 38, 28, 28, 82, -61, + -61, 81, -61, 77, 109, -61, -177, 78, -194, -289, + -394, 732, 77, -411, 28, 530, 531, 504, -444, 199, + 239, 236, 74, -444, -439, 369, -414, -413, -412, -442, + -443, -289, -442, -442, -442, 517, -442, -442, -442, -442, + -442, -442, -442, -442, -442, -418, -444, 332, 77, -444, + -414, -412, 203, -376, -378, 438, 439, 531, 532, 373, + 373, 373, 373, 373, 373, -140, -140, 203, 251, -133, + 28, -231, -230, -290, -283, -285, -286, 226, -289, -280, + -465, -329, -326, -325, -327, 477, 525, 142, 537, -148, + -412, -161, -131, -131, -129, -131, 64, 64, 64, 69, + 64, 69, 69, 64, 64, -144, -299, -272, 77, -461, + -461, -461, -9, -460, -299, -163, -272, 200, 200, 200, + 102, 16, 52, 26, 102, 16, 52, 26, 102, 16, + 52, 26, -118, -117, -120, 134, -121, -297, -175, -241, + 96, 14, 119, 77, 23, 77, -227, 30, 31, 187, + -176, 59, 84, 87, -241, 77, -119, -148, -121, -121, + -121, -192, 92, 100, 93, 94, -291, 226, 134, -298, + -290, -285, -283, 346, 230, -280, -175, -193, -199, -136, + 88, 119, 117, 118, 102, -175, -175, -175, -175, -175, + -175, -175, -175, -175, -175, -175, -175, -175, -175, -175, + -300, 82, 81, 143, 82, -290, -117, -290, -174, 225, + 471, 472, 92, -174, -289, -289, -107, 26, 27, -290, + 518, -290, -107, -107, -107, -107, -107, 77, -461, -117, + -117, -117, -461, -121, -121, -117, -175, -117, -202, 81, + -117, -202, 81, -117, -175, 556, 557, 558, -117, -117, + -107, -203, -204, 104, -202, -283, -286, 346, 230, -117, + -461, 84, -181, -182, 638, 647, 648, 650, 653, 646, + 645, 644, 642, 641, 640, 643, 639, 657, 656, 655, + 654, 652, 651, 649, -181, -181, -183, 225, 473, 471, + 472, -117, -118, -117, -117, -461, -461, -120, -117, -120, + -117, -117, -461, -461, -461, -461, -117, -117, -117, -117, + -117, -117, -117, -117, -117, -117, -117, -117, -461, 84, + -150, 96, -148, -124, -148, -140, -103, 16, 75, -103, + 77, 187, -249, -252, 77, 529, 531, 532, -246, -321, + -322, 142, 74, 95, 81, -121, -290, -298, -228, -372, + -341, -342, -343, -344, -365, 214, -380, 206, 208, 209, + 49, -345, 215, 200, 50, -305, -331, 510, 511, -313, + 76, -312, 76, -67, 475, 474, 477, -312, 475, 482, + -312, 482, 482, -312, -312, -312, 475, 76, 76, -313, + -313, -313, -333, 76, -333, 470, -334, 76, -334, -334, + -334, -334, -305, -305, -305, -305, -305, -381, -121, -229, + -293, 75, -232, 202, 719, -329, 29, -329, -68, 251, + 220, 187, 76, -161, 254, 255, -416, 77, 33, -422, + 329, 84, 205, -148, 230, -148, -148, -412, -412, -418, + -391, 218, 213, -148, 77, 77, 187, 698, 698, -148, + 77, 81, 82, 82, -177, -349, 16, 119, -261, -148, + -177, -115, 226, 75, -462, -461, 447, 448, 82, -175, + 38, 38, -60, -174, -289, 78, -395, 204, 549, 81, + -410, -299, 503, 531, -445, 134, -289, -444, -445, -448, + 635, 203, 78, 77, -442, -445, 349, 332, -445, 16, + -375, -377, 431, 432, 433, 434, 435, 436, 437, 77, + 109, 109, -379, 24, -374, 635, -374, 81, -175, -135, + -461, 77, 187, -199, 34, -351, -352, -351, -351, -80, + -387, -78, -385, 195, 192, 191, 265, 197, -324, 550, +>>>>>>> Stashed changes 248, 247, 281, 282, 73, 35, 196, 193, -70, -79, 229, 287, 233, 288, 194, 228, 289, 227, 290, 635, 285, 739, 508, 600, 601, 602, 90, 603, 245, 41, 200, 605, 537, 374, 606, 607, 210, 608, 609, 610, +<<<<<<< Updated upstream 338, 611, 612, 613, 614, 615, 616, 363, 9, -419, -425, 74, -135, -134, 74, 75, -136, 74, -134, 64, 64, 64, -232, 76, -296, -126, -459, -234, -286, -160, @@ -11603,11 +11941,160 @@ var yyChk = [...]int{ 77, -459, 633, 71, 636, -218, 124, 123, -191, 14, -9, -380, -458, 21, -459, -230, -172, -458, 109, 84, 81, 81, 217, -459, -367, -366, -276, 635, -9, 250, +======= + 338, 611, 612, 613, 614, 615, 616, 363, 9, -422, + -428, 74, -138, -137, 74, 75, -139, 74, -137, 64, + 64, 64, -235, 76, -299, -129, -461, -237, -289, -163, + -299, -460, -460, -460, -175, -175, 119, -175, -175, 119, + -175, -175, 119, -461, 77, 187, 77, -238, 40, 39, + -289, 505, 60, -178, -178, -214, -255, 24, 16, 55, + 55, -126, 16, -225, -225, 92, 93, 94, 187, -460, + -193, -175, -175, -175, -115, 99, -461, -461, -118, -117, + -117, -117, -117, -117, -121, -461, -461, -461, 77, 75, + 28, -461, 75, 119, -461, 16, 16, -461, 16, 16, + -461, -461, 16, -175, -175, -175, -461, -461, -117, -206, + -204, 106, -121, -461, -461, -461, -461, -461, 77, 77, + 16, 77, -461, -461, -461, -461, -215, 565, -215, -461, + -461, -461, -461, -461, -215, -215, -215, -215, -461, -461, + -461, -461, -461, -461, -461, -461, -461, -461, -461, -461, + -461, -236, 122, -148, 34, -236, 75, -124, -124, -151, + -297, 134, -251, -254, 533, 530, 536, 82, 81, 143, + 81, 187, -229, -357, -371, 77, 122, 739, 508, 600, + -324, 601, 602, 90, 603, 245, 41, 200, 605, 537, + 374, 606, 607, 210, 608, 609, 610, 338, 611, 441, + 612, 613, 614, 615, 616, 363, 9, 76, -350, -288, + -380, 82, -282, 50, -345, -347, -345, -345, -350, 82, + -282, -350, 50, 701, 92, 100, -320, -322, 143, -317, + -318, -335, -338, -314, 28, 740, 513, 217, -344, 477, + 525, 33, 74, 508, 206, 50, 49, 209, 90, -332, + 512, 84, 84, 576, -312, 482, -312, -312, -312, -312, + -312, -339, 81, -339, 84, -333, 84, 78, 74, -289, + 28, -148, 659, -69, 13, 14, 15, -289, -397, -398, + -399, -289, 119, 256, 257, 74, -431, 360, -420, 330, + 339, 99, 21, 635, -452, 100, 203, 203, -148, -412, + -289, 74, 74, -240, -164, 17, 82, 82, -258, -261, + -175, -415, 242, 243, -175, -175, -149, 96, -411, 203, + 187, 187, -445, 203, 351, -414, -289, 16, 16, 349, + 16, -414, 77, 109, 109, 109, 109, 109, 109, 109, + -378, 76, 76, 383, 530, -230, -290, -351, 82, 81, + 143, 82, 81, 143, 81, -386, 77, -387, 195, 192, + 281, 282, -385, -273, -345, -393, -392, -343, -344, 122, + 207, 214, 214, 211, -273, -345, 206, 215, 122, 214, + 211, -273, 200, -351, -273, 477, 142, 203, 37, 37, + 363, 122, 363, 122, -351, -273, 207, -345, -270, 214, + -271, 203, 28, 286, 122, 122, 122, 122, 122, 122, + 122, 122, 291, -351, -351, -351, -351, -351, -351, -351, + -351, 604, 604, -351, -351, -351, -351, -351, -351, -351, + -351, -351, -351, -351, -351, -351, -351, -351, -351, -355, + -449, 81, -459, 90, 269, 338, 82, -282, -280, 84, + 86, 85, -351, -162, 193, 275, 271, -121, 76, -121, + -233, -289, -235, -461, 77, -163, -233, -233, -233, 99, + 203, -460, 99, 203, -460, 99, 203, -460, -272, -120, + 134, -298, 81, 77, 81, 81, 506, 61, -148, -164, + 597, -124, -119, 134, -290, -118, -115, 99, -175, -461, + -461, -461, -461, -461, -461, -303, 143, 474, 477, 225, + 473, 466, 464, 463, 465, 493, 479, 510, 471, 511, + 646, -300, -303, -300, -175, -175, -175, -175, -175, -175, + 16, 16, 16, 632, -210, 108, -121, 105, -175, -175, + -175, -175, -289, -220, -460, -215, -215, -215, -215, -215, + -216, -215, -216, -216, -216, -216, -216, -216, -216, -216, + -216, -216, -216, -171, -172, 34, -170, -9, -460, -173, + -466, 55, 59, -460, -243, -248, -202, -283, -286, 226, + -164, -124, -164, -164, 187, 530, 534, 535, -371, 21, + -351, -351, -351, 525, 477, 142, -351, -351, -351, -351, + -351, 604, 604, -351, -351, -351, -351, -351, -351, -351, + -351, -351, -351, -351, 442, -351, -351, -351, -351, -351, + -355, -449, -351, -367, -366, 82, -287, 206, 49, -380, + -350, -350, -350, -350, -101, -288, 92, -460, 741, 84, + -148, 34, 82, 143, -174, 133, -301, -166, -185, -460, + 93, 94, 541, 542, 546, 543, 547, 548, 561, 562, + 563, 564, 538, 544, 545, 14, 50, 50, 50, 81, + 78, 78, 78, -312, 78, 77, 78, 77, 78, 77, + -168, 693, 694, -148, -224, -232, 84, 74, 78, 77, + -304, -289, -289, -289, 271, -434, 635, 335, -432, -430, + 341, 342, 343, 344, 345, -415, 340, -422, 337, 81, + 82, 81, 658, 692, 713, 685, 29, -148, -412, -234, + 76, -233, -234, -121, -177, -236, 199, -414, 134, 134, + -289, 203, -414, 349, -447, 635, -414, -414, 16, -414, + -377, 81, 81, 81, 84, 84, 84, 84, -140, -140, + 81, 35, 82, 81, 143, -78, 195, 192, 281, 282, + 76, -340, 82, -287, -350, -266, 208, 206, -460, 82, + -288, -288, -288, -289, 50, 50, -237, -288, -288, -289, + -288, 33, 278, 279, 280, 82, 34, -351, 477, -237, + 26, -237, 26, 33, 335, 283, 284, -340, -288, -289, + -148, 215, 211, -288, -237, 26, 84, -237, -289, -237, + 26, -237, 26, -237, 26, -237, 26, -355, -121, -355, + -459, -459, 81, 81, 81, -351, -351, -459, 81, -449, + 81, -102, 216, 219, 221, -355, -355, -355, -459, 81, + -356, 33, 620, 469, 621, 622, 623, 82, 92, 81, + 81, 33, -459, 33, -459, -355, 617, -460, -427, 247, + 248, 203, 276, 100, -424, 738, 272, -233, 78, 77, + -153, -289, -461, -461, -461, -175, -175, -175, -175, -175, + -175, -175, -175, -175, -299, 187, 520, -289, -319, -320, + -207, 18, -225, -461, -175, -216, -216, -216, -216, -216, + -461, -313, -313, -313, -313, -334, 470, -313, 454, -313, + 454, -461, -461, -461, -461, 24, 24, 24, 24, -461, + -175, -175, -175, -460, -114, 560, -121, 77, 77, -461, + -461, -294, 82, -242, 74, -242, -243, -272, -9, -461, + -231, -173, -460, 11, 55, 59, 635, 199, -197, -200, + -465, -237, -164, 77, -352, -352, -352, -352, -210, -164, + -358, -359, -362, -361, 123, 624, 673, -355, -355, -355, + -351, 34, -351, -459, -459, 81, 81, 81, -351, -351, + -459, 81, -449, 81, -102, -355, -355, -355, -459, 81, + -356, 82, 92, 81, 81, 33, -459, 33, -459, -355, + 617, -460, 78, 77, -313, -313, 50, -347, 76, -175, + 28, 76, 82, 143, -174, 81, -175, -191, 81, 84, + 84, 76, -226, 28, -452, -148, -400, -401, -402, 90, + 634, 100, 258, 259, 216, 260, 261, 262, -399, -304, + -304, -304, -424, -437, -438, -436, 338, 358, 359, 346, + -435, -433, 353, 354, 355, 356, 99, 81, 81, 81, + -423, 329, 99, 338, 21, 28, 28, 81, 81, 81, + 81, 84, 75, -233, -261, -319, -148, -447, -414, -447, + 332, -414, 78, 78, -340, -212, 219, 220, -304, -304, + -293, -347, 50, -382, -384, 122, -288, 693, 694, 693, + 694, 34, 192, 731, 701, -340, -351, -300, 34, 363, + 363, 363, 363, -212, -271, 203, 50, -288, 203, 363, + 363, 96, 635, 81, 81, 618, 619, -450, -449, -316, + 90, 74, -161, 276, -428, 74, -180, -174, -185, -174, + 78, -289, 77, 77, 77, 134, -460, -403, -259, -208, + 19, 21, -319, 82, -319, 82, -175, -175, -175, -175, + -461, -461, -461, -175, -461, 81, -175, -175, -196, 122, + 32, -242, -299, -461, -173, -460, -461, -461, 77, -199, + -460, -461, -210, -248, -121, -121, -121, -121, -228, -363, + 626, -460, 520, 625, 50, -300, -351, -323, -449, 81, + 81, 81, 618, 619, -450, -369, -368, 75, 210, 90, + 606, 613, 731, 701, -366, -227, -227, -350, -350, -233, + -461, -460, -233, -461, 78, 78, -367, -9, -224, 24, + -225, -402, 81, 262, 258, 262, 262, 262, 262, 263, + -428, -419, 90, 336, -436, 347, 699, 331, 360, 84, + 84, 121, 35, 36, -433, 84, 84, 84, 84, -430, + 21, 635, -422, 337, 81, 81, 81, 329, -452, 41, + 78, -403, -446, 28, -447, -446, 349, 78, 82, -305, + -305, 76, -350, -350, -461, 77, -289, 33, 33, -212, + -300, -300, -288, -289, -288, 203, -288, -460, 199, 77, + -461, 326, 81, 365, -162, -429, -182, -175, -175, -175, + -454, -455, -290, 706, -404, 43, -406, 44, -218, 566, + -209, -121, -195, -123, -121, -461, -461, -461, -461, -112, + 119, 635, -461, -461, -210, 21, 50, -235, -173, -9, + -460, -200, -461, -228, -360, 627, 84, -175, -460, -460, + -275, 265, -300, -461, -368, -449, -351, 81, -351, -351, + 78, -330, 743, 742, -175, 78, 78, -224, -226, 249, + -226, 41, 41, 254, 255, -427, 81, 81, 33, 348, + 186, 33, 84, 186, 568, 337, 81, 82, 338, 21, + -175, -404, -412, -446, -367, -293, 76, -384, 55, -175, + 142, 142, 203, -288, -382, -148, -449, -224, -427, 132, + -425, 273, -461, -461, -461, -461, 77, -304, 24, 81, + 599, -407, 48, -405, -337, 47, 21, -217, -219, -289, + 77, -461, 633, 71, 636, -221, 124, 123, -194, 14, + -9, -383, -460, 21, -461, -233, -175, -460, 109, 84, + 81, 81, 217, -461, -370, -369, -279, 635, -9, 250, +>>>>>>> Stashed changes -27, -4, -16, -17, -18, -19, -21, -71, -22, -23, -28, -29, -24, -81, -85, -86, -87, -83, -94, -92, -93, -89, -88, -32, -34, -35, -37, -40, -41, -38, -39, -36, -30, -33, -42, -25, -43, -44, -45, -50, -51, -31, -52, -46, 103, 205, 441, 307, 318, 319, +<<<<<<< Updated upstream 320, 82, 323, 325, 321, 322, 317, 327, 440, -313, 84, 33, 84, 33, 350, 338, 28, 84, -312, 204, 635, 78, 76, -364, 234, -348, -297, -285, -459, -70, @@ -11647,6 +12134,47 @@ var yyChk = [...]int{ 108, 106, -58, -118, -63, -172, 82, 320, -118, 746, 323, 325, 82, 74, 74, 84, -361, -385, 218, 213, 216, 34, -385, 108, 103, 746, 205, -54, 105, 82, +======= + 320, 82, 323, 325, 321, 322, 317, 327, 440, -316, + 84, 33, 84, 33, 350, 338, 28, 84, -315, 204, + 635, 78, 76, -367, 234, -351, -300, -288, -461, -70, + -27, -316, 186, -426, 274, -180, -461, -455, -456, 599, + 29, 712, 520, 81, -406, 21, -408, 45, 46, 81, + 77, 28, -123, 61, 634, 637, -461, -222, 102, -223, + 121, 568, -179, 84, 186, -222, -243, -461, -382, -361, + -461, -461, -233, 84, -148, -330, 211, 277, 503, -224, + -213, 252, 253, -224, -121, -55, -56, 104, -121, 82, + -65, -295, 310, 311, 312, -290, 82, 82, -54, -27, + 80, -54, -121, 82, 82, -104, 16, 58, -175, 108, + -54, 326, 642, 642, 81, -235, 84, 330, -370, -367, + 78, 235, -300, 286, -224, 326, -174, -180, -429, -272, + 81, 599, -460, 520, 81, 21, 21, -219, -220, 61, + -223, 126, 127, 250, 126, 127, -174, -461, 625, 50, + -461, 76, 349, 211, 211, -279, -224, 82, 82, -55, + 108, 106, -56, -121, 105, 308, 309, 313, -304, 77, + 746, 440, 320, 323, 325, 746, 326, 82, 16, 746, + -224, -244, 34, 43, 124, 33, 335, 26, -415, 78, + -370, -460, -224, -182, -429, -299, -457, -458, 375, 92, + 33, 81, -454, -460, 81, 81, 635, 99, -181, -460, + -275, -233, 349, 349, -226, 108, 106, 103, -54, 105, + -54, 24, 24, 24, -319, -290, 108, -27, 108, -54, + -54, -54, -121, 324, -54, 96, 108, -27, -243, 8, + -370, -175, 232, -27, -458, 92, 33, -457, 92, 33, + 74, 74, -174, -461, -454, 636, -223, -175, -460, 78, + -20, -26, -19, -25, -16, -17, -18, 440, 635, 103, + -54, 746, -54, 746, -66, 84, -9, -64, -63, 84, + -66, 315, 100, 316, 82, -321, 320, 82, 746, 746, + 746, 326, -121, 746, -59, 82, -224, -415, -461, -461, + -224, 74, -174, 74, -174, 665, 375, 665, 375, 74, + -461, 637, -461, -175, -389, -390, 74, -224, -54, 108, + -127, 746, 108, 746, 108, 106, -57, -58, 107, -27, + 77, 314, 33, 108, 108, 324, -54, 108, 108, 77, + 74, 74, 375, 375, 665, 375, -364, 628, -461, -390, + 74, -389, 74, 15, 14, 746, 108, 103, 205, -54, + 108, 106, -58, -121, -63, -175, 82, 320, -121, 746, + 323, 325, 82, 74, 74, 84, -364, -388, 218, 213, + 216, 34, -388, 108, 103, 746, 205, -54, 105, 82, +>>>>>>> Stashed changes 108, 108, 375, 665, 212, 33, 92, 108, 746, -54, 323, 325, 205, 108, 746, 82, 82, 205, } @@ -12593,4216 +13121,4265 @@ yydefault: case 1: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:669 +//line sql3.y:526 { - setParseTree(yylex, yyDollar[1].statement) + setParseTree(yylex, yyDollar[1].val.(Statement)) } case 2: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:673 +//line sql3.y:530 { - setParseTree(yylex, yyDollar[1].statement) + setParseTree(yylex, yyDollar[1].val.(Statement)) statementSeen(yylex) } case 3: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:680 +//line sql3.y:537 { - yyVAL.statement = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 4: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:684 +//line sql3.y:541 { - yyVAL.statement = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 41: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:724 +//line sql3.y:581 { setParseTree(yylex, nil) } case 42: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:729 +//line sql3.y:586 { - yyVAL.assignExprs = nil + yyVAL.val = AssignmentExprs(nil) } case 43: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:733 +//line sql3.y:590 { - yyVAL.assignExprs = yyDollar[2].assignExprs + yyVAL.val = yyDollar[2].val.(AssignmentExprs) } case 44: yyDollar = yyS[yypt-13 : yypt+1] -//line sql.y:739 +//line sql3.y:596 { - yyVAL.statement = &Load{Local: yyDollar[3].boolVal, Infile: yyDollar[4].str, IgnoreOrReplace: yyDollar[5].str, Table: yyDollar[6].tableName, Partition: yyDollar[7].partitions, Charset: yyDollar[8].str, Fields: yyDollar[9].Fields, Lines: yyDollar[10].Lines, IgnoreNum: yyDollar[11].sqlVal, Columns: yyDollar[12].columns, SetExprs: yyDollar[13].assignExprs} + yyVAL.val = &Load{Local: yyDollar[3].val.(BoolVal), Infile: yyDollar[4].val.(string), IgnoreOrReplace: yyDollar[5].val.(string), Table: yyDollar[6].val.(TableName), Partition: yyDollar[7].val.(Partitions), Charset: yyDollar[8].val.(string), Fields: yyDollar[9].val.(*Fields), Lines: yyDollar[10].val.(*Lines), IgnoreNum: yyDollar[11].val.(*SQLVal), Columns: yyDollar[12].val.(Columns), SetExprs: yyDollar[13].val.(AssignmentExprs)} } case 45: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:745 +//line sql3.y:602 { - yyDollar[1].selStmt.SetOrderBy(yyDollar[2].orderBy) - yyDollar[1].selStmt.SetLimit(yyDollar[3].limit) - yyDollar[1].selStmt.SetLock(yyDollar[4].str) - if err := yyDollar[1].selStmt.SetInto(yyDollar[5].into); err != nil { + yyDollar[1].val.(SelectStatement).SetOrderBy(yyDollar[2].val.(OrderBy)) + yyDollar[1].val.(SelectStatement).SetLimit(yyDollar[3].val.(*Limit)) + yyDollar[1].val.(SelectStatement).SetLock(yyDollar[4].val.(string)) + if err := yyDollar[1].val.(SelectStatement).SetInto(yyDollar[5].val.(*Into)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 46: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:756 +//line sql3.y:613 { - yyVAL.selStmt = &Select{ - Comments: Comments(yyDollar[2].bytes2), - QueryOpts: yyDollar[3].queryOpts, - SelectExprs: SelectExprs{Nextval{Expr: yyDollar[5].expr}}, - From: TableExprs{&AliasedTableExpr{Expr: yyDollar[7].tableName}}, + yyVAL.val = &Select{ + Comments: Comments(yyDollar[2].val.([][]byte)), + QueryOpts: yyDollar[3].val.(QueryOpts), + SelectExprs: SelectExprs{Nextval{Expr: yyDollar[5].val.(Expr)}}, + From: TableExprs{&AliasedTableExpr{Expr: yyDollar[7].val.(TableName)}}, } } case 47: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:767 +//line sql3.y:624 { - yyVAL.selStmt = &Select{ + yyVAL.val = &Select{ SelectExprs: SelectExprs{&StarExpr{}}, - From: TableExprs{&AliasedTableExpr{Expr: yyDollar[1].simpleTableExpr}}, - OrderBy: yyDollar[2].orderBy, - Limit: yyDollar[3].limit, + From: TableExprs{&AliasedTableExpr{Expr: yyDollar[1].val.(SimpleTableExpr)}}, + OrderBy: yyDollar[2].val.(OrderBy), + Limit: yyDollar[3].val.(*Limit), } } case 48: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:776 +//line sql3.y:633 { - yyVAL.selStmt = yyDollar[2].selStmt + yyVAL.val = yyDollar[2].val.(SelectStatement) } case 49: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:782 +//line sql3.y:639 { - if yyDollar[1].selStmt.GetInto() != nil { + if yyDollar[1].val.(SelectStatement).GetInto() != nil { yylex.Error(fmt.Errorf("INTO clause is not allowed").Error()) return 1 } - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 50: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:792 +//line sql3.y:649 { - yyVAL.statement = &Stream{Comments: Comments(yyDollar[2].bytes2), SelectExpr: yyDollar[3].selectExpr, Table: yyDollar[5].tableName} + yyVAL.val = &Stream{Comments: Comments(yyDollar[2].val.([][]byte)), SelectExpr: yyDollar[3].val.(SelectExpr), Table: yyDollar[5].val.(TableName)} } case 51: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:800 +//line sql3.y:657 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 52: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:804 +//line sql3.y:661 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 53: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:811 +//line sql3.y:668 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 54: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:815 +//line sql3.y:672 { - yyVAL.selStmt = &SetOp{Type: yyDollar[2].str, Left: yyDollar[1].selStmt, Right: yyDollar[3].selStmt} + yyVAL.val = &SetOp{Type: yyDollar[2].val.(string), Left: yyDollar[1].val.(SelectStatement), Right: yyDollar[3].val.(SelectStatement)} } case 55: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:819 +//line sql3.y:676 { - yyVAL.selStmt = &SetOp{Type: yyDollar[2].str, Left: yyDollar[1].selStmt, Right: yyDollar[3].selStmt} + yyVAL.val = &SetOp{Type: yyDollar[2].val.(string), Left: yyDollar[1].val.(SelectStatement), Right: yyDollar[3].val.(SelectStatement)} } case 56: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:828 +//line sql3.y:685 { - yyVAL.selStmt = &SetOp{Type: yyDollar[2].str, Left: yyDollar[1].selStmt, Right: yyDollar[3].selStmt} + yyVAL.val = &SetOp{Type: yyDollar[2].val.(string), Left: yyDollar[1].val.(SelectStatement), Right: yyDollar[3].val.(SelectStatement)} } case 57: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:832 +//line sql3.y:689 { - yyVAL.selStmt = &SetOp{Type: yyDollar[2].str, Left: yyDollar[1].selStmt, Right: yyDollar[3].selStmt} + yyVAL.val = &SetOp{Type: yyDollar[2].val.(string), Left: yyDollar[1].val.(SelectStatement), Right: yyDollar[3].val.(SelectStatement)} } case 58: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:839 +//line sql3.y:696 { - if yyDollar[1].selStmt.GetInto() != nil { + if yyDollar[1].val.(SelectStatement).GetInto() != nil { yylex.Error(fmt.Errorf("INTO clause is not allowed").Error()) return 1 } - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 59: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:847 +//line sql3.y:704 { - yyVAL.selStmt = &ParenSelect{Select: yyDollar[2].selStmt} + yyVAL.val = &ParenSelect{Select: yyDollar[2].val.(SelectStatement)} } case 60: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:855 +//line sql3.y:712 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 61: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:859 +//line sql3.y:716 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 62: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:867 +//line sql3.y:724 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 63: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:871 +//line sql3.y:728 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 64: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:877 +//line sql3.y:734 { - yyVAL.selStmt = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 65: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:881 +//line sql3.y:738 { - yyDollar[3].selStmt.SetWith(yyDollar[2].with) - yyVAL.selStmt = yyDollar[3].selStmt + yyDollar[3].val.(SelectStatement).SetWith(yyDollar[2].val.(*With)) + yyVAL.val = yyDollar[3].val.(SelectStatement) } case 66: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:888 +//line sql3.y:745 { - yyVAL.with = &With{Ctes: yyDollar[2].tableExprs, Recursive: true} + yyVAL.val = &With{Ctes: yyDollar[2].val.(TableExprs), Recursive: true} } case 67: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:891 +//line sql3.y:748 { - yyVAL.with = &With{Ctes: yyDollar[1].tableExprs, Recursive: false} + yyVAL.val = &With{Ctes: yyDollar[1].val.(TableExprs), Recursive: false} } case 68: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:897 - { - yyVAL.selStmt = &Select{ - Comments: Comments(yyDollar[2].bytes2), - QueryOpts: yyDollar[3].queryOpts, - SelectExprs: yyDollar[4].selectExprs, - Into: yyDollar[5].into, - From: yyDollar[6].tableExprs, - Where: NewWhere(WhereStr, yyDollar[7].expr), - GroupBy: GroupBy(yyDollar[8].exprs), - Having: NewWhere(HavingStr, yyDollar[9].expr), - Window: yyDollar[10].window, +//line sql3.y:754 + { + wh, _ := yyDollar[7].val.(Expr) + ha, _ := yyDollar[9].val.(Expr) + yyVAL.val = &Select{ + Comments: Comments(yyDollar[2].val.([][]byte)), + QueryOpts: yyDollar[3].val.(QueryOpts), + SelectExprs: yyDollar[4].val.(SelectExprs), + Into: yyDollar[5].val.(*Into), + From: yyDollar[6].val.(TableExprs), + Where: NewWhere(WhereStr, wh), + GroupBy: GroupBy(yyDollar[8].val.(Exprs)), + Having: NewWhere(HavingStr, ha), + Window: yyDollar[10].val.(Window), } } case 69: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:911 +//line sql3.y:770 { - yyVAL.selStmt = &Select{SelectExprs: SelectExprs{&StarExpr{}}, From: TableExprs{yyDollar[2].tableExpr}} + yyVAL.val = &Select{SelectExprs: SelectExprs{&StarExpr{}}, From: TableExprs{yyDollar[2].val.(TableExpr)}} } case 70: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:916 +//line sql3.y:775 { - yyVAL.tableExprs = nil + yyVAL.val = []byte(nil) } case 71: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:920 +//line sql3.y:779 { - yyVAL.tableExprs = nil + yyVAL.val = []byte(nil) } case 72: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:924 +//line sql3.y:783 { - yyVAL.tableExprs = yyDollar[2].tableExprs + yyVAL.val = yyDollar[2].val.(TableExprs) } case 73: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:933 +//line sql3.y:792 { - yyVAL.into = nil + yyVAL.val = &Into{} } case 74: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:937 +//line sql3.y:796 { - yyVAL.into = &Into{Variables: yyDollar[2].variables} + yyVAL.val = &Into{Variables: yyDollar[2].val.(Variables)} } case 75: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:941 +//line sql3.y:800 { - yyVAL.into = &Into{Dumpfile: string(yyDollar[3].bytes)} + yyVAL.val = &Into{Dumpfile: string(yyDollar[3].bytes)} } case 76: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:945 +//line sql3.y:804 { - yyVAL.into = &Into{Outfile: string(yyDollar[3].bytes), Charset: yyDollar[4].str, Fields: yyDollar[5].Fields, Lines: yyDollar[6].Lines} + yyVAL.val = &Into{Outfile: string(yyDollar[3].bytes), Charset: yyDollar[4].val.(string), Fields: yyDollar[5].val.(*Fields), Lines: yyDollar[6].val.(*Lines)} } case 77: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:951 +//line sql3.y:810 { - yyVAL.variables = Variables{yyDollar[1].colIdent} + yyVAL.val = Variables{yyDollar[1].val.(ColIdent)} } case 78: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:955 +//line sql3.y:814 { - yyVAL.variables = append(yyVAL.variables, yyDollar[3].colIdent) + yyVAL.val = append(yyVAL.val.(Variables), yyDollar[3].val.(ColIdent)) } case 79: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:960 +//line sql3.y:819 { - yyVAL.with = nil + yyVAL.val = &With{} } case 80: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:964 +//line sql3.y:823 { - yyVAL.with = yyDollar[2].with + yyVAL.val = yyDollar[2].val.(*With) } case 81: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:970 +//line sql3.y:829 { - yyVAL.tableExprs = TableExprs{yyDollar[1].tableExpr} + yyVAL.val = TableExprs{yyDollar[1].val.(TableExpr)} } case 82: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:974 +//line sql3.y:833 { - yyVAL.tableExprs = append(yyDollar[1].tableExprs, yyDollar[3].tableExpr) + yyVAL.val = append(yyDollar[1].val.(TableExprs), yyDollar[3].val.(TableExpr)) } case 83: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:980 +//line sql3.y:839 { - yyVAL.tableExpr = &CommonTableExpr{&AliasedTableExpr{Expr: yyDollar[4].simpleTableExpr, As: yyDollar[1].tableIdent}, yyDollar[2].columns} + yyVAL.val = &CommonTableExpr{&AliasedTableExpr{Expr: yyDollar[4].val.(SimpleTableExpr), As: yyDollar[1].val.(TableIdent)}, yyDollar[2].val.(Columns)} } case 84: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:986 +//line sql3.y:845 { // insert_data returns a *Insert pre-filled with Columns & Values - ins := yyDollar[7].ins - ins.Action = yyDollar[2].str - ins.Comments = yyDollar[3].bytes2 - ins.Ignore = yyDollar[4].str - ins.Table = yyDollar[5].tableName - ins.Partitions = yyDollar[6].partitions - ins.OnDup = OnDup(yyDollar[8].assignExprs) - ins.With = yyDollar[1].with - yyVAL.statement = ins + ins := yyDollar[7].val.(*Insert) + ins.Action = yyDollar[2].val.(string) + ins.Comments = yyDollar[3].val.([][]byte) + ins.Ignore = yyDollar[4].val.(string) + ins.Table = yyDollar[5].val.(TableName) + ins.Partitions = yyDollar[6].val.(Partitions) + ins.OnDup = OnDup(yyDollar[8].val.(AssignmentExprs)) + ins.With = yyDollar[1].val.(*With) + yyVAL.val = ins } case 85: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:999 +//line sql3.y:858 { // insert_data returns a *Insert pre-filled with Columns & Values - ins := yyDollar[7].ins - ins.Action = yyDollar[2].str - ins.Comments = yyDollar[3].bytes2 - ins.Ignore = yyDollar[4].str - ins.Table = yyDollar[5].tableName - ins.Partitions = yyDollar[6].partitions - ins.OnDup = OnDup(yyDollar[8].assignExprs) - ins.With = yyDollar[1].with - yyVAL.statement = ins + ins := yyDollar[7].val.(*Insert) + ins.Action = yyDollar[2].val.(string) + ins.Comments = yyDollar[3].val.([][]byte) + ins.Ignore = yyDollar[4].val.(string) + ins.Table = yyDollar[5].val.(TableName) + ins.Partitions = yyDollar[6].val.(Partitions) + ins.OnDup = OnDup(yyDollar[8].val.(AssignmentExprs)) + ins.With = yyDollar[1].val.(*With) + yyVAL.val = ins } case 86: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1012 +//line sql3.y:871 { - cols := make(Columns, 0, len(yyDollar[8].assignExprs)) - vals := make(ValTuple, 0, len(yyDollar[9].assignExprs)) - for _, updateList := range yyDollar[8].assignExprs { + cols := make(Columns, 0, len(yyDollar[8].val.(AssignmentExprs))) + vals := make(ValTuple, 0, len(yyDollar[9].val.(AssignmentExprs))) + for _, updateList := range yyDollar[8].val.(AssignmentExprs) { cols = append(cols, updateList.Name.Name) vals = append(vals, updateList.Expr) } - yyVAL.statement = &Insert{Action: yyDollar[2].str, Comments: Comments(yyDollar[3].bytes2), Ignore: yyDollar[4].str, Table: yyDollar[5].tableName, Partitions: yyDollar[6].partitions, Columns: cols, Rows: &AliasedValues{Values: Values{vals}}, OnDup: OnDup(yyDollar[9].assignExprs), With: yyDollar[1].with} + yyVAL.val = &Insert{Action: yyDollar[2].val.(string), Comments: Comments(yyDollar[3].val.([][]byte)), Ignore: yyDollar[4].val.(string), Table: yyDollar[5].val.(TableName), Partitions: yyDollar[6].val.(Partitions), Columns: cols, Rows: &AliasedValues{Values: Values{vals}}, OnDup: OnDup(yyDollar[9].val.(AssignmentExprs)), With: yyDollar[1].val.(*With)} } case 87: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1024 +//line sql3.y:883 { - yyVAL.str = InsertStr + yyVAL.val = InsertStr } case 88: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1028 +//line sql3.y:887 { - yyVAL.str = ReplaceStr + yyVAL.val = ReplaceStr } case 89: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:1034 +//line sql3.y:893 { - yyVAL.statement = &Update{Comments: Comments(yyDollar[3].bytes2), Ignore: yyDollar[4].str, TableExprs: yyDollar[5].tableExprs, Exprs: yyDollar[7].assignExprs, Where: NewWhere(WhereStr, yyDollar[8].expr), OrderBy: yyDollar[9].orderBy, Limit: yyDollar[10].limit, With: yyDollar[1].with} + yyVAL.val = &Update{Comments: Comments(yyDollar[3].val.([][]byte)), Ignore: yyDollar[4].val.(string), TableExprs: yyDollar[5].val.(TableExprs), Exprs: yyDollar[7].val.(AssignmentExprs), Where: NewWhere(WhereStr, yyDollar[8].val.(Expr)), OrderBy: yyDollar[9].val.(OrderBy), Limit: yyDollar[10].val.(*Limit), With: yyDollar[1].val.(*With)} } case 90: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1040 +//line sql3.y:899 { - yyVAL.statement = &Delete{Comments: Comments(yyDollar[3].bytes2), TableExprs: TableExprs{&AliasedTableExpr{Expr: yyDollar[5].tableName}}, Partitions: yyDollar[6].partitions, Where: NewWhere(WhereStr, yyDollar[7].expr), OrderBy: yyDollar[8].orderBy, Limit: yyDollar[9].limit, With: yyDollar[1].with} + yyVAL.val = &Delete{Comments: Comments(yyDollar[3].val.([][]byte)), TableExprs: TableExprs{&AliasedTableExpr{Expr: yyDollar[5].val.(TableName)}}, Partitions: yyDollar[6].val.(Partitions), Where: NewWhere(WhereStr, yyDollar[7].val.(Expr)), OrderBy: yyDollar[8].val.(OrderBy), Limit: yyDollar[9].val.(*Limit), With: yyDollar[1].val.(*With)} } case 91: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:1044 +//line sql3.y:903 { - yyVAL.statement = &Delete{Comments: Comments(yyDollar[3].bytes2), Targets: yyDollar[5].tableNames, TableExprs: yyDollar[7].tableExprs, Where: NewWhere(WhereStr, yyDollar[8].expr), With: yyDollar[1].with} + yyVAL.val = &Delete{Comments: Comments(yyDollar[3].val.([][]byte)), Targets: yyDollar[5].val.(TableNames), TableExprs: yyDollar[7].val.(TableExprs), Where: NewWhere(WhereStr, yyDollar[8].val.(Expr)), With: yyDollar[1].val.(*With)} } case 92: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1048 +//line sql3.y:907 { - yyVAL.statement = &Delete{Comments: Comments(yyDollar[3].bytes2), Targets: yyDollar[4].tableNames, TableExprs: yyDollar[6].tableExprs, Where: NewWhere(WhereStr, yyDollar[7].expr), With: yyDollar[1].with} + yyVAL.val = &Delete{Comments: Comments(yyDollar[3].val.([][]byte)), Targets: yyDollar[4].val.(TableNames), TableExprs: yyDollar[6].val.(TableExprs), Where: NewWhere(WhereStr, yyDollar[7].val.(Expr)), With: yyDollar[1].val.(*With)} } case 93: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1052 +//line sql3.y:911 { - yyVAL.statement = &Delete{Comments: Comments(yyDollar[3].bytes2), Targets: yyDollar[4].tableNames, TableExprs: yyDollar[6].tableExprs, Where: NewWhere(WhereStr, yyDollar[7].expr), With: yyDollar[1].with} + yyVAL.val = &Delete{Comments: Comments(yyDollar[3].val.([][]byte)), Targets: yyDollar[4].val.(TableNames), TableExprs: yyDollar[6].val.(TableExprs), Where: NewWhere(WhereStr, yyDollar[7].val.(Expr)), With: yyDollar[1].val.(*With)} } case 94: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1057 +//line sql3.y:916 { } case 95: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1058 +//line sql3.y:917 { } case 96: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1062 +//line sql3.y:921 { - yyVAL.tableNames = TableNames{yyDollar[1].tableName.ToViewName()} + yyVAL.val = TableNames{yyDollar[1].val.(TableName).ToViewName()} } case 97: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1066 +//line sql3.y:925 { - yyVAL.tableNames = append(yyVAL.tableNames, yyDollar[3].tableName.ToViewName()) + yyVAL.val = append(yyVAL.val.(TableNames), yyDollar[3].val.(TableName).ToViewName()) } case 98: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1072 +//line sql3.y:931 { - yyVAL.tableNames = TableNames{yyDollar[1].tableName} + yyVAL.val = TableNames{yyDollar[1].val.(TableName)} } case 99: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1076 +//line sql3.y:935 { - yyVAL.tableNames = append(yyVAL.tableNames, yyDollar[3].tableName) + yyVAL.val = append(yyVAL.val.(TableNames), yyDollar[3].val.(TableName)) } case 100: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1082 +//line sql3.y:941 { - yyVAL.tableNames = TableNames{yyDollar[1].tableName} + yyVAL.val = TableNames{yyDollar[1].val.(TableName)} } case 101: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1086 +//line sql3.y:945 { - yyVAL.tableNames = append(yyVAL.tableNames, yyDollar[3].tableName) + yyVAL.val = append(yyVAL.val.(TableNames), yyDollar[3].val.(TableName)) } case 102: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1091 +//line sql3.y:950 { - yyVAL.partitions = nil + yyVAL.val = Partitions(nil) } case 103: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1095 +//line sql3.y:954 { - yyVAL.partitions = yyDollar[3].partitions + yyVAL.val = yyDollar[3].val.(Partitions) } case 104: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1101 +//line sql3.y:960 { - yyVAL.statement = &Set{Comments: Comments(yyDollar[2].bytes2), Exprs: yyDollar[3].setVarExprs} + yyVAL.val = &Set{Comments: Comments(yyDollar[2].val.([][]byte)), Exprs: yyDollar[3].val.(SetVarExprs)} } case 105: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1105 +//line sql3.y:964 { - for i := 0; i < len(yyDollar[4].setVarExprs); i++ { - yyDollar[4].setVarExprs[i].Scope = SetScope_None + for i := 0; i < len(yyDollar[4].val.(SetVarExprs)); i++ { + yyDollar[4].val.(SetVarExprs)[i].Scope = SetScope_None } - yyVAL.statement = &Set{Comments: Comments(yyDollar[2].bytes2), Exprs: yyDollar[4].setVarExprs} + yyVAL.val = &Set{Comments: Comments(yyDollar[2].val.([][]byte)), Exprs: yyDollar[4].val.(SetVarExprs)} } case 106: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1112 +//line sql3.y:971 { - for i := 0; i < len(yyDollar[5].setVarExprs); i++ { - yyDollar[5].setVarExprs[i].Scope = yyDollar[3].setScope + for i := 0; i < len(yyDollar[5].val.(SetVarExprs)); i++ { + yyDollar[5].val.(SetVarExprs)[i].Scope = yyDollar[3].val.(SetScope) } - yyVAL.statement = &Set{Comments: Comments(yyDollar[2].bytes2), Exprs: yyDollar[5].setVarExprs} + yyVAL.val = &Set{Comments: Comments(yyDollar[2].val.([][]byte)), Exprs: yyDollar[5].val.(SetVarExprs)} } case 107: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1121 +//line sql3.y:980 { - yyVAL.setVarExprs = SetVarExprs{yyDollar[1].setVarExpr} + yyVAL.val = SetVarExprs{yyDollar[1].val.(*SetVarExpr)} } case 108: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1125 +//line sql3.y:984 { - yyVAL.setVarExprs = append(yyVAL.setVarExprs, yyDollar[3].setVarExpr) + yyVAL.val = append(yyVAL.val.(SetVarExprs), yyDollar[3].val.(*SetVarExpr)) } case 109: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1131 +//line sql3.y:990 { - yyVAL.setVarExpr = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(yyDollar[3].str))} + yyVAL.val = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(yyDollar[3].val.(string)))} } case 110: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1135 +//line sql3.y:994 { - yyVAL.setVarExpr = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(TxReadWrite))} + yyVAL.val = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(TxReadWrite))} } case 111: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1139 +//line sql3.y:998 { - yyVAL.setVarExpr = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(TxReadOnly))} + yyVAL.val = &SetVarExpr{Name: NewColName(TransactionStr), Expr: NewStrVal([]byte(TxReadOnly))} } case 112: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1145 +//line sql3.y:1004 { - yyVAL.str = IsolationLevelRepeatableRead + yyVAL.val = IsolationLevelRepeatableRead } case 113: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1149 +//line sql3.y:1008 { - yyVAL.str = IsolationLevelReadCommitted + yyVAL.val = IsolationLevelReadCommitted } case 114: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1153 +//line sql3.y:1012 { - yyVAL.str = IsolationLevelReadUncommitted + yyVAL.val = IsolationLevelReadUncommitted } case 115: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1157 +//line sql3.y:1016 { - yyVAL.str = IsolationLevelSerializable + yyVAL.val = IsolationLevelSerializable } case 116: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1162 +//line sql3.y:1021 { - yyVAL.int = yyPosition(yylex) + yyVAL.val = yyPosition(yylex) } case 117: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1167 +//line sql3.y:1026 { - yyVAL.int = yyOldPosition(yylex) + yyVAL.val = yyOldPosition(yylex) } case 118: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1172 +//line sql3.y:1031 { - yyVAL.boolean = yySpecialCommentMode(yylex) + yyVAL.val = yySpecialCommentMode(yylex) } case 119: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1178 +//line sql3.y:1037 { - yyDollar[1].ddl.TableSpec = yyDollar[2].TableSpec - if len(yyDollar[1].ddl.TableSpec.Constraints) > 0 { - yyDollar[1].ddl.ConstraintAction = AddStr + yyDollar[1].val.(*DDL).TableSpec = yyDollar[2].val.(*TableSpec) + if len(yyDollar[1].val.(*DDL).TableSpec.Constraints) > 0 { + yyDollar[1].val.(*DDL).ConstraintAction = AddStr } - yyVAL.statement = yyDollar[1].ddl + yyVAL.val = yyDollar[1].val.(*DDL) } case 120: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1187 +//line sql3.y:1046 { - yyDollar[1].ddl.OptSelect = &OptSelect{Select: yyDollar[3].selStmt} - yyVAL.statement = yyDollar[1].ddl + yyDollar[1].val.(*DDL).OptSelect = &OptSelect{Select: yyDollar[3].val.(SelectStatement)} + yyVAL.val = yyDollar[1].val.(*DDL) } case 121: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1196 +//line sql3.y:1055 { - yyDollar[1].ddl.OptSelect = &OptSelect{Select: yyDollar[2].selStmt} - yyVAL.statement = yyDollar[1].ddl + yyDollar[1].val.(*DDL).OptSelect = &OptSelect{Select: yyDollar[2].val.(SelectStatement)} + yyVAL.val = yyDollar[1].val.(*DDL) } case 122: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1201 +//line sql3.y:1060 { - yyDollar[1].ddl.OptLike = &OptLike{LikeTable: yyDollar[3].tableName} - yyVAL.statement = yyDollar[1].ddl + yyDollar[1].val.(*DDL).OptLike = &OptLike{LikeTable: yyDollar[3].val.(TableName)} + yyVAL.val = yyDollar[1].val.(*DDL) } case 123: yyDollar = yyS[yypt-11 : yypt+1] -//line sql.y:1206 +//line sql3.y:1065 { // For consistency, we always return AlterTable for any ALTER TABLE-equivalent statements - ddl := &DDL{Action: AlterStr, Table: yyDollar[7].tableName, IndexSpec: &IndexSpec{Action: CreateStr, ToName: yyDollar[4].colIdent, Using: yyDollar[5].colIdent, Type: yyDollar[2].str, Columns: yyDollar[9].indexColumns, Options: yyDollar[11].indexOptions}} - yyVAL.statement = &AlterTable{Table: yyDollar[7].tableName, Statements: []*DDL{ddl}} + ddl := &DDL{Action: AlterStr, Table: yyDollar[7].val.(TableName), IndexSpec: &IndexSpec{Action: CreateStr, ToName: yyDollar[4].val.(ColIdent), Using: yyDollar[5].val.(ColIdent), Type: yyDollar[2].val.(string), Columns: yyDollar[9].val.([]*IndexColumn), Options: yyDollar[11].val.([]*IndexOption)}} + yyVAL.val = &AlterTable{Table: yyDollar[7].val.(TableName), Statements: []*DDL{ddl}} } case 124: yyDollar = yyS[yypt-11 : yypt+1] -//line sql.y:1212 +//line sql3.y:1071 { - yyDollar[2].viewSpec.ViewName = yyDollar[4].tableName.ToViewName() - yyDollar[2].viewSpec.ViewExpr = yyDollar[9].selStmt - yyDollar[2].viewSpec.Columns = yyDollar[5].columns - yyDollar[2].viewSpec.CheckOption = yyDollar[11].viewCheckOption - yyVAL.statement = &DDL{Action: CreateStr, ViewSpec: yyDollar[2].viewSpec, SpecialCommentMode: yyDollar[8].boolean, SubStatementPositionStart: yyDollar[7].int, SubStatementPositionEnd: yyDollar[10].int - 1} + yyDollar[2].val.(*ViewSpec).ViewName = yyDollar[4].val.(TableName).ToViewName() + yyDollar[2].val.(*ViewSpec).ViewExpr = yyDollar[9].val.(SelectStatement) + yyDollar[2].val.(*ViewSpec).Columns = yyDollar[5].val.(Columns) + yyDollar[2].val.(*ViewSpec).CheckOption = yyDollar[11].val.(ViewCheckOption) + yyVAL.val = &DDL{Action: CreateStr, ViewSpec: yyDollar[2].val.(*ViewSpec), SpecialCommentMode: yyDollar[8].val.(bool), SubStatementPositionStart: yyDollar[7].val.(int), SubStatementPositionEnd: yyDollar[10].val.(int) - 1} } case 125: yyDollar = yyS[yypt-13 : yypt+1] -//line sql.y:1220 +//line sql3.y:1079 { - yyDollar[4].viewSpec.ViewName = yyDollar[6].tableName.ToViewName() - yyDollar[4].viewSpec.ViewExpr = yyDollar[11].selStmt - yyDollar[4].viewSpec.Columns = yyDollar[7].columns - yyDollar[4].viewSpec.CheckOption = yyDollar[13].viewCheckOption - yyVAL.statement = &DDL{Action: CreateStr, ViewSpec: yyDollar[4].viewSpec, SpecialCommentMode: yyDollar[10].boolean, SubStatementPositionStart: yyDollar[9].int, SubStatementPositionEnd: yyDollar[12].int - 1, OrReplace: true} + yyDollar[4].val.(*ViewSpec).ViewName = yyDollar[6].val.(TableName).ToViewName() + yyDollar[4].val.(*ViewSpec).ViewExpr = yyDollar[11].val.(SelectStatement) + yyDollar[4].val.(*ViewSpec).Columns = yyDollar[7].val.(Columns) + yyDollar[4].val.(*ViewSpec).CheckOption = yyDollar[13].val.(ViewCheckOption) + yyVAL.val = &DDL{Action: CreateStr, ViewSpec: yyDollar[4].val.(*ViewSpec), SpecialCommentMode: yyDollar[10].val.(bool), SubStatementPositionStart: yyDollar[9].val.(int), SubStatementPositionEnd: yyDollar[12].val.(int) - 1, OrReplace: true} } case 126: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1228 +//line sql3.y:1087 { var ne bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { ne = true } - yyVAL.statement = &DBDDL{Action: CreateStr, SchemaOrDatabase: "database", DBName: string(yyDollar[4].bytes), IfNotExists: ne, CharsetCollate: yyDollar[5].charsetCollates} + yyVAL.val = &DBDDL{Action: CreateStr, SchemaOrDatabase: "database", DBName: string(yyDollar[4].bytes), IfNotExists: ne, CharsetCollate: yyDollar[5].val.([]*CharsetAndCollate)} } case 127: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1236 +//line sql3.y:1095 { var ne bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { ne = true } - yyVAL.statement = &DBDDL{Action: CreateStr, SchemaOrDatabase: "schema", DBName: string(yyDollar[4].bytes), IfNotExists: ne, CharsetCollate: yyDollar[5].charsetCollates} + yyVAL.val = &DBDDL{Action: CreateStr, SchemaOrDatabase: "schema", DBName: string(yyDollar[4].bytes), IfNotExists: ne, CharsetCollate: yyDollar[5].val.([]*CharsetAndCollate)} } case 128: yyDollar = yyS[yypt-16 : yypt+1] -//line sql.y:1244 +//line sql3.y:1103 { - yyVAL.statement = &DDL{Action: CreateStr, Table: yyDollar[8].tableName, TriggerSpec: &TriggerSpec{TrigName: yyDollar[4].triggerName, Definer: yyDollar[2].str, Time: yyDollar[5].str, Event: yyDollar[6].str, Order: yyDollar[12].triggerOrder, Body: yyDollar[15].statement}, SpecialCommentMode: yyDollar[14].boolean, SubStatementPositionStart: yyDollar[13].int, SubStatementPositionEnd: yyDollar[16].int - 1} + yyVAL.val = &DDL{Action: CreateStr, Table: yyDollar[8].val.(TableName), TriggerSpec: &TriggerSpec{TrigName: yyDollar[4].val.(TriggerName), Definer: yyDollar[2].val.(string), Time: yyDollar[5].val.(string), Event: yyDollar[6].val.(string), Order: yyDollar[12].val.(*TriggerOrder), Body: yyDollar[15].val.(Statement)}, SpecialCommentMode: yyDollar[14].val.(bool), SubStatementPositionStart: yyDollar[13].val.(int), SubStatementPositionEnd: yyDollar[16].val.(int) - 1} } case 129: yyDollar = yyS[yypt-12 : yypt+1] -//line sql.y:1248 +//line sql3.y:1107 { - yyVAL.statement = &DDL{Action: CreateStr, ProcedureSpec: &ProcedureSpec{ProcName: yyDollar[4].procedureName, Definer: yyDollar[2].str, Params: yyDollar[6].procedureParams, Characteristics: yyDollar[8].characteristics, Body: yyDollar[11].statement}, SpecialCommentMode: yyDollar[10].boolean, SubStatementPositionStart: yyDollar[9].int, SubStatementPositionEnd: yyDollar[12].int - 1} + yyVAL.val = &DDL{Action: CreateStr, ProcedureSpec: &ProcedureSpec{ProcName: yyDollar[4].val.(ProcedureName), Definer: yyDollar[2].val.(string), Params: yyDollar[6].val.([]ProcedureParam), Characteristics: yyDollar[8].val.([]Characteristic), Body: yyDollar[11].val.(Statement)}, SpecialCommentMode: yyDollar[10].val.(bool), SubStatementPositionStart: yyDollar[9].val.(int), SubStatementPositionEnd: yyDollar[12].val.(int) - 1} } case 130: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1252 +//line sql3.y:1111 { var notExists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { notExists = true } - tlsOptions, err := NewTLSOptions(yyDollar[6].tlsOptionItems) + tlsOptions, err := NewTLSOptions(yyDollar[6].val.([]TLSOptionItem)) if err != nil { yylex.Error(err.Error()) return 1 } - accountLimits, err := NewAccountLimits(yyDollar[7].accountLimitItems) + accountLimits, err := NewAccountLimits(yyDollar[7].val.([]AccountLimitItem)) if err != nil { yylex.Error(err.Error()) return 1 } - passwordOptions, locked := NewPasswordOptionsWithLock(yyDollar[8].passLockItems) - yyVAL.statement = &CreateUser{IfNotExists: notExists, Users: yyDollar[4].accountsWithAuth, DefaultRoles: yyDollar[5].accountNames, TLSOptions: tlsOptions, AccountLimits: accountLimits, PasswordOptions: passwordOptions, Locked: locked, Attribute: yyDollar[9].str} + passwordOptions, locked := NewPasswordOptionsWithLock(yyDollar[8].val.([]PassLockItem)) + yyVAL.val = &CreateUser{IfNotExists: notExists, Users: yyDollar[4].val.([]AccountWithAuth), DefaultRoles: yyDollar[5].val.([]AccountName), TLSOptions: tlsOptions, AccountLimits: accountLimits, PasswordOptions: passwordOptions, Locked: locked, Attribute: yyDollar[9].val.(string)} } case 131: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1271 +//line sql3.y:1130 { var notExists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { notExists = true } - yyVAL.statement = &CreateRole{IfNotExists: notExists, Roles: yyDollar[4].accountNames} + yyVAL.val = &CreateRole{IfNotExists: notExists, Roles: yyDollar[4].val.([]AccountName)} } case 132: yyDollar = yyS[yypt-15 : yypt+1] -//line sql.y:1279 +//line sql3.y:1138 { var notExists bool - if yyDollar[4].byt != 0 { + if yyDollar[4].val.(byte) != 0 { notExists = true } - yyVAL.statement = &DDL{Action: CreateStr, EventSpec: &EventSpec{EventName: yyDollar[5].eventName, Definer: yyDollar[2].str, IfNotExists: notExists, OnSchedule: yyDollar[8].eventScheduleSpec, OnCompletionPreserve: yyDollar[9].eventOnCompletion, Status: yyDollar[10].eventStatus, Comment: yyDollar[11].sqlVal, Body: yyDollar[14].statement}, SubStatementPositionStart: yyDollar[13].int, SubStatementPositionEnd: yyDollar[15].int - 1} + yyVAL.val = &DDL{Action: CreateStr, EventSpec: &EventSpec{EventName: yyDollar[5].val.(EventName), Definer: yyDollar[2].val.(string), IfNotExists: notExists, OnSchedule: yyDollar[8].val.(*EventScheduleSpec), OnCompletionPreserve: yyDollar[9].val.(EventOnCompletion), Status: yyDollar[10].val.(EventStatus), Comment: yyDollar[11].val.(*SQLVal), Body: yyDollar[14].val.(Statement)}, SubStatementPositionStart: yyDollar[13].val.(int), SubStatementPositionEnd: yyDollar[15].val.(int) - 1} } case 133: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1287 +//line sql3.y:1146 { - yyVAL.statement = yyDollar[1].statement + yyVAL.val = yyDollar[1].val.(Statement) } case 134: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:1293 +//line sql3.y:1152 { - yyVAL.statement = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[5].bytes), SrsAttr: yyDollar[6].srsAttr} + yyVAL.val = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[5].bytes), SrsAttr: yyDollar[6].val.(*SrsAttribute)} } case 135: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1297 +//line sql3.y:1156 { - yyVAL.statement = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[8].bytes), IfNotExists: true, SrsAttr: yyDollar[9].srsAttr} + yyVAL.val = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[8].bytes), IfNotExists: true, SrsAttr: yyDollar[9].val.(*SrsAttribute)} } case 136: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:1301 +//line sql3.y:1160 { - yyVAL.statement = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[7].bytes), OrReplace: true, SrsAttr: yyDollar[8].srsAttr} + yyVAL.val = &CreateSpatialRefSys{SRID: NewIntVal(yyDollar[7].bytes), OrReplace: true, SrsAttr: yyDollar[8].val.(*SrsAttribute)} } case 137: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1306 +//line sql3.y:1165 { - yyVAL.srsAttr = &SrsAttribute{} + yyVAL.val = &SrsAttribute{} } case 138: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1310 +//line sql3.y:1169 { - if yyDollar[1].srsAttr.Name != "" { + if yyDollar[1].val.(*SrsAttribute).Name != "" { yylex.Error("multiple definitions of attribute name") return 1 } - yyDollar[1].srsAttr.Name = string(yyDollar[3].bytes) - yyVAL.srsAttr = yyDollar[1].srsAttr + yyDollar[1].val.(*SrsAttribute).Name = string(yyDollar[3].bytes) + yyVAL.val = yyDollar[1].val.(*SrsAttribute) } case 139: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1319 +//line sql3.y:1178 { - if yyDollar[1].srsAttr.Definition != "" { + if yyDollar[1].val.(*SrsAttribute).Definition != "" { yylex.Error("multiple definitions of attribute definition") return 1 } - yyDollar[1].srsAttr.Definition = string(yyDollar[3].bytes) - yyVAL.srsAttr = yyDollar[1].srsAttr + yyDollar[1].val.(*SrsAttribute).Definition = string(yyDollar[3].bytes) + yyVAL.val = yyDollar[1].val.(*SrsAttribute) } case 140: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:1328 +//line sql3.y:1187 { - if yyDollar[1].srsAttr.Organization != "" { + if yyDollar[1].val.(*SrsAttribute).Organization != "" { yylex.Error("multiple definitions of attribute organization") return 1 } - yyDollar[1].srsAttr.Organization = string(yyDollar[3].bytes) - yyDollar[1].srsAttr.OrgID = NewIntVal(yyDollar[6].bytes) - yyVAL.srsAttr = yyDollar[1].srsAttr + yyDollar[1].val.(*SrsAttribute).Organization = string(yyDollar[3].bytes) + yyDollar[1].val.(*SrsAttribute).OrgID = NewIntVal(yyDollar[6].bytes) + yyVAL.val = yyDollar[1].val.(*SrsAttribute) } case 141: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1338 +//line sql3.y:1197 { - if yyDollar[1].srsAttr.Description != "" { + if yyDollar[1].val.(*SrsAttribute).Description != "" { yylex.Error("multiple definitions of attribute description") return 1 } - yyDollar[1].srsAttr.Description = string(yyDollar[3].bytes) - yyVAL.srsAttr = yyDollar[1].srsAttr + yyDollar[1].val.(*SrsAttribute).Description = string(yyDollar[3].bytes) + yyVAL.val = yyDollar[1].val.(*SrsAttribute) } case 142: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1349 +//line sql3.y:1208 { - yyVAL.viewCheckOption = ViewCheckOptionUnspecified + yyVAL.val = ViewCheckOptionUnspecified } case 143: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1353 +//line sql3.y:1212 { - yyVAL.viewCheckOption = ViewCheckOptionCascaded + yyVAL.val = ViewCheckOptionCascaded } case 144: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1357 +//line sql3.y:1216 { - yyVAL.viewCheckOption = ViewCheckOptionCascaded + yyVAL.val = ViewCheckOptionCascaded } case 145: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1361 +//line sql3.y:1220 { - yyVAL.viewCheckOption = ViewCheckOptionLocal + yyVAL.val = ViewCheckOptionLocal } case 146: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1366 +//line sql3.y:1225 { - yyVAL.accountNames = nil + yyVAL.val = []AccountName(nil) } case 147: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1370 +//line sql3.y:1229 { - yyVAL.accountNames = yyDollar[3].accountNames + yyVAL.val = yyDollar[3].val.([]AccountName) } case 148: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1375 +//line sql3.y:1234 { - yyVAL.tlsOptionItems = nil + yyVAL.val = []TLSOptionItem(nil) } case 149: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1379 +//line sql3.y:1238 { - yyVAL.tlsOptionItems = nil + yyVAL.val = []TLSOptionItem(nil) } case 150: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1383 +//line sql3.y:1242 { - yyVAL.tlsOptionItems = yyDollar[2].tlsOptionItems + yyVAL.val = yyDollar[2].val.([]TLSOptionItem) } case 151: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1389 +//line sql3.y:1248 { - yyVAL.tlsOptionItems = []TLSOptionItem{yyDollar[1].tlsOptionItem} + yyVAL.val = []TLSOptionItem{yyDollar[1].val.(TLSOptionItem)} } case 152: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1393 +//line sql3.y:1252 { - yyVAL.tlsOptionItems = append(yyDollar[1].tlsOptionItems, yyDollar[3].tlsOptionItem) + yyVAL.val = append(yyDollar[1].val.([]TLSOptionItem), yyDollar[3].val.(TLSOptionItem)) } case 153: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1399 +//line sql3.y:1258 { - yyVAL.tlsOptionItem = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_SSL, ItemData: ""} + yyVAL.val = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_SSL, ItemData: ""} } case 154: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1403 +//line sql3.y:1262 { - yyVAL.tlsOptionItem = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_X509, ItemData: ""} + yyVAL.val = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_X509, ItemData: ""} } case 155: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1407 +//line sql3.y:1266 { - yyVAL.tlsOptionItem = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Cipher, ItemData: string(yyDollar[2].bytes)} + yyVAL.val = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Cipher, ItemData: string(yyDollar[2].bytes)} } case 156: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1411 +//line sql3.y:1270 { - yyVAL.tlsOptionItem = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Issuer, ItemData: string(yyDollar[2].bytes)} + yyVAL.val = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Issuer, ItemData: string(yyDollar[2].bytes)} } case 157: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1415 +//line sql3.y:1274 { - yyVAL.tlsOptionItem = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Subject, ItemData: string(yyDollar[2].bytes)} + yyVAL.val = TLSOptionItem{TLSOptionItemType: TLSOptionItemType_Subject, ItemData: string(yyDollar[2].bytes)} } case 158: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1420 +//line sql3.y:1279 { - yyVAL.accountLimitItems = nil + yyVAL.val = []AccountLimitItem(nil) } case 159: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1424 +//line sql3.y:1283 { - yyVAL.accountLimitItems = yyDollar[2].accountLimitItems + yyVAL.val = yyDollar[2].val.([]AccountLimitItem) } case 160: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1430 +//line sql3.y:1289 { - yyVAL.accountLimitItems = []AccountLimitItem{yyDollar[1].accountLimitItem} + yyVAL.val = []AccountLimitItem{yyDollar[1].val.(AccountLimitItem)} } case 161: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1434 +//line sql3.y:1293 { - yyVAL.accountLimitItems = append(yyDollar[1].accountLimitItems, yyDollar[2].accountLimitItem) + yyVAL.val = append(yyDollar[1].val.([]AccountLimitItem), yyDollar[2].val.(AccountLimitItem)) } case 162: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1440 +//line sql3.y:1299 { - yyVAL.accountLimitItem = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Queries_PH, Count: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Queries_PH, Count: NewIntVal(yyDollar[2].bytes)} } case 163: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1444 +//line sql3.y:1303 { - yyVAL.accountLimitItem = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Updates_PH, Count: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Updates_PH, Count: NewIntVal(yyDollar[2].bytes)} } case 164: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1448 +//line sql3.y:1307 { - yyVAL.accountLimitItem = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Connections_PH, Count: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Connections_PH, Count: NewIntVal(yyDollar[2].bytes)} } case 165: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1452 +//line sql3.y:1311 { - yyVAL.accountLimitItem = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Connections, Count: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = AccountLimitItem{AccountLimitItemType: AccountLimitItemType_Connections, Count: NewIntVal(yyDollar[2].bytes)} } case 166: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1457 +//line sql3.y:1316 { - yyVAL.passLockItems = nil + yyVAL.val = []PassLockItem(nil) } case 167: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1461 +//line sql3.y:1320 { - yyVAL.passLockItems = yyDollar[1].passLockItems + yyVAL.val = yyDollar[1].val.([]PassLockItem) } case 168: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1467 +//line sql3.y:1326 { - yyVAL.passLockItems = []PassLockItem{yyDollar[1].passLockItem} + yyVAL.val = []PassLockItem{yyDollar[1].val.(PassLockItem)} } case 169: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1471 +//line sql3.y:1330 { - yyVAL.passLockItems = append(yyDollar[1].passLockItems, yyDollar[2].passLockItem) + yyVAL.val = append(yyDollar[1].val.([]PassLockItem), yyDollar[2].val.(PassLockItem)) } case 170: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1477 +//line sql3.y:1336 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassExpireDefault, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassExpireDefault, Value: nil} } case 171: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1481 +//line sql3.y:1340 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassExpireNever, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassExpireNever, Value: nil} } case 172: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1485 +//line sql3.y:1344 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassExpireInterval, Value: NewIntVal(yyDollar[4].bytes)} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassExpireInterval, Value: NewIntVal(yyDollar[4].bytes)} } case 173: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1489 +//line sql3.y:1348 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassHistory, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassHistory, Value: nil} } case 174: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1493 +//line sql3.y:1352 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassHistory, Value: NewIntVal(yyDollar[3].bytes)} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassHistory, Value: NewIntVal(yyDollar[3].bytes)} } case 175: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1497 +//line sql3.y:1356 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassReuseInterval, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassReuseInterval, Value: nil} } case 176: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1501 +//line sql3.y:1360 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassReuseInterval, Value: NewIntVal(yyDollar[4].bytes)} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassReuseInterval, Value: NewIntVal(yyDollar[4].bytes)} } case 177: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1505 +//line sql3.y:1364 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassReqCurrentDefault, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassReqCurrentDefault, Value: nil} } case 178: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1509 +//line sql3.y:1368 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassReqCurrentOptional, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassReqCurrentOptional, Value: nil} } case 179: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1513 +//line sql3.y:1372 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassFailedLogins, Value: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassFailedLogins, Value: NewIntVal(yyDollar[2].bytes)} } case 180: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1517 +//line sql3.y:1376 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassLockTime, Value: NewIntVal(yyDollar[2].bytes)} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassLockTime, Value: NewIntVal(yyDollar[2].bytes)} } case 181: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1521 +//line sql3.y:1380 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_PassLockTime, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_PassLockTime, Value: nil} } case 182: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1525 +//line sql3.y:1384 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_AccountLock, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_AccountLock, Value: nil} } case 183: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1529 +//line sql3.y:1388 { - yyVAL.passLockItem = PassLockItem{PassLockItemType: PassLockItemType_AccountUnlock, Value: nil} + yyVAL.val = PassLockItem{PassLockItemType: PassLockItemType_AccountUnlock, Value: nil} } case 184: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1534 +//line sql3.y:1393 { - yyVAL.str = "" + yyVAL.val = "" } case 185: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1538 +//line sql3.y:1397 { comment := string(yyDollar[2].bytes) - yyVAL.str = `{"comment": "` + escapeDoubleQuotes(comment) + `"}` + yyVAL.val = `{"comment": "` + escapeDoubleQuotes(comment) + `"}` } case 186: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1543 +//line sql3.y:1402 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 187: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1549 +//line sql3.y:1408 { allPriv := []Privilege{Privilege{Type: PrivilegeType_All, Columns: nil}} - yyVAL.statement = &GrantPrivilege{Privileges: allPriv, ObjectType: yyDollar[4].grantObjectType, PrivilegeLevel: yyDollar[5].privilegeLevel, To: yyDollar[7].accountNames, WithGrantOption: yyDollar[8].boolean, As: yyDollar[9].grantAssumption} + yyVAL.val = &GrantPrivilege{Privileges: allPriv, ObjectType: yyDollar[4].val.(GrantObjectType), PrivilegeLevel: yyDollar[5].val.(PrivilegeLevel), To: yyDollar[7].val.([]AccountName), WithGrantOption: yyDollar[8].val.(bool), As: yyDollar[9].val.(*GrantUserAssumption)} } case 188: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:1554 +//line sql3.y:1413 { allPriv := []Privilege{Privilege{Type: PrivilegeType_All, Columns: nil}} - yyVAL.statement = &GrantPrivilege{Privileges: allPriv, ObjectType: yyDollar[5].grantObjectType, PrivilegeLevel: yyDollar[6].privilegeLevel, To: yyDollar[8].accountNames, WithGrantOption: yyDollar[9].boolean, As: yyDollar[10].grantAssumption} + yyVAL.val = &GrantPrivilege{Privileges: allPriv, ObjectType: yyDollar[5].val.(GrantObjectType), PrivilegeLevel: yyDollar[6].val.(PrivilegeLevel), To: yyDollar[8].val.([]AccountName), WithGrantOption: yyDollar[9].val.(bool), As: yyDollar[10].val.(*GrantUserAssumption)} } case 189: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:1559 +//line sql3.y:1418 { - yyVAL.statement = &GrantPrivilege{Privileges: yyDollar[2].grantPrivileges, ObjectType: yyDollar[4].grantObjectType, PrivilegeLevel: yyDollar[5].privilegeLevel, To: yyDollar[7].accountNames, WithGrantOption: yyDollar[8].boolean, As: yyDollar[9].grantAssumption} + yyVAL.val = &GrantPrivilege{Privileges: yyDollar[2].val.([]Privilege), ObjectType: yyDollar[4].val.(GrantObjectType), PrivilegeLevel: yyDollar[5].val.(PrivilegeLevel), To: yyDollar[7].val.([]AccountName), WithGrantOption: yyDollar[8].val.(bool), As: yyDollar[9].val.(*GrantUserAssumption)} } case 190: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1563 +//line sql3.y:1422 { - yyVAL.statement = &GrantRole{Roles: yyDollar[2].accountNames, To: yyDollar[4].accountNames, WithAdminOption: yyDollar[5].boolean} + yyVAL.val = &GrantRole{Roles: yyDollar[2].val.([]AccountName), To: yyDollar[4].val.([]AccountName), WithAdminOption: yyDollar[5].val.(bool)} } case 191: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1567 +//line sql3.y:1426 { - yyVAL.statement = &GrantProxy{On: yyDollar[4].accountName, To: yyDollar[6].accountNames, WithGrantOption: yyDollar[7].boolean} + yyVAL.val = &GrantProxy{On: yyDollar[4].val.(AccountName), To: yyDollar[6].val.([]AccountName), WithGrantOption: yyDollar[7].val.(bool)} } case 192: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1573 +//line sql3.y:1432 { allPriv := []Privilege{Privilege{Type: PrivilegeType_All, Columns: nil}} - yyVAL.statement = &RevokePrivilege{Privileges: allPriv, ObjectType: yyDollar[4].grantObjectType, PrivilegeLevel: yyDollar[5].privilegeLevel, From: yyDollar[7].accountNames} + yyVAL.val = &RevokePrivilege{Privileges: allPriv, ObjectType: yyDollar[4].val.(GrantObjectType), PrivilegeLevel: yyDollar[5].val.(PrivilegeLevel), From: yyDollar[7].val.([]AccountName)} } case 193: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1578 +//line sql3.y:1437 { - yyVAL.statement = &RevokePrivilege{Privileges: yyDollar[2].grantPrivileges, ObjectType: yyDollar[4].grantObjectType, PrivilegeLevel: yyDollar[5].privilegeLevel, From: yyDollar[7].accountNames} + yyVAL.val = &RevokePrivilege{Privileges: yyDollar[2].val.([]Privilege), ObjectType: yyDollar[4].val.(GrantObjectType), PrivilegeLevel: yyDollar[5].val.(PrivilegeLevel), From: yyDollar[7].val.([]AccountName)} } case 194: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1582 +//line sql3.y:1441 { - yyVAL.statement = &RevokeAllPrivileges{From: yyDollar[7].accountNames} + yyVAL.val = &RevokeAllPrivileges{From: yyDollar[7].val.([]AccountName)} } case 195: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:1586 +//line sql3.y:1445 { - yyVAL.statement = &RevokeAllPrivileges{From: yyDollar[8].accountNames} + yyVAL.val = &RevokeAllPrivileges{From: yyDollar[8].val.([]AccountName)} } case 196: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1590 +//line sql3.y:1449 { - yyVAL.statement = &RevokeRole{Roles: yyDollar[2].accountNames, From: yyDollar[4].accountNames} + yyVAL.val = &RevokeRole{Roles: yyDollar[2].val.([]AccountName), From: yyDollar[4].val.([]AccountName)} } case 197: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:1594 +//line sql3.y:1453 { - yyVAL.statement = &RevokeProxy{On: yyDollar[4].accountName, From: yyDollar[6].accountNames} + yyVAL.val = &RevokeProxy{On: yyDollar[4].val.(AccountName), From: yyDollar[6].val.([]AccountName)} } case 198: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1600 +//line sql3.y:1459 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Alter, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Alter, Columns: yyDollar[2].val.([]string)} } case 199: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1604 +//line sql3.y:1463 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_AlterRoutine, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_AlterRoutine, Columns: yyDollar[3].val.([]string)} } case 200: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1608 +//line sql3.y:1467 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Create, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Create, Columns: yyDollar[2].val.([]string)} } case 201: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1612 +//line sql3.y:1471 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateRole, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateRole, Columns: yyDollar[3].val.([]string)} } case 202: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1616 +//line sql3.y:1475 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateRoutine, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateRoutine, Columns: yyDollar[3].val.([]string)} } case 203: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1620 +//line sql3.y:1479 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateTablespace, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateTablespace, Columns: yyDollar[3].val.([]string)} } case 204: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1624 +//line sql3.y:1483 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateTemporaryTables, Columns: yyDollar[4].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateTemporaryTables, Columns: yyDollar[4].val.([]string)} } case 205: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1628 +//line sql3.y:1487 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateUser, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateUser, Columns: yyDollar[3].val.([]string)} } case 206: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1632 +//line sql3.y:1491 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_CreateView, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_CreateView, Columns: yyDollar[3].val.([]string)} } case 207: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1636 +//line sql3.y:1495 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Delete, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Delete, Columns: yyDollar[2].val.([]string)} } case 208: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1640 +//line sql3.y:1499 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Drop, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Drop, Columns: yyDollar[2].val.([]string)} } case 209: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1644 +//line sql3.y:1503 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_DropRole, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_DropRole, Columns: yyDollar[3].val.([]string)} } case 210: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1648 +//line sql3.y:1507 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Event, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Event, Columns: yyDollar[2].val.([]string)} } case 211: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1652 +//line sql3.y:1511 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Execute, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Execute, Columns: yyDollar[2].val.([]string)} } case 212: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1656 +//line sql3.y:1515 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_File, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_File, Columns: yyDollar[2].val.([]string)} } case 213: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1660 +//line sql3.y:1519 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_GrantOption, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_GrantOption, Columns: yyDollar[3].val.([]string)} } case 214: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1664 +//line sql3.y:1523 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Index, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Index, Columns: yyDollar[2].val.([]string)} } case 215: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1668 +//line sql3.y:1527 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Insert, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Insert, Columns: yyDollar[2].val.([]string)} } case 216: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1672 +//line sql3.y:1531 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_LockTables, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_LockTables, Columns: yyDollar[3].val.([]string)} } case 217: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1676 +//line sql3.y:1535 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Process, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Process, Columns: yyDollar[2].val.([]string)} } case 218: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1680 +//line sql3.y:1539 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_References, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_References, Columns: yyDollar[2].val.([]string)} } case 219: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1684 +//line sql3.y:1543 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Reload, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Reload, Columns: yyDollar[2].val.([]string)} } case 220: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1688 +//line sql3.y:1547 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_ReplicationClient, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_ReplicationClient, Columns: yyDollar[3].val.([]string)} } case 221: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1692 +//line sql3.y:1551 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_ReplicationSlave, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_ReplicationSlave, Columns: yyDollar[3].val.([]string)} } case 222: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1696 +//line sql3.y:1555 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Select, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Select, Columns: yyDollar[2].val.([]string)} } case 223: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1700 +//line sql3.y:1559 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_ShowDatabases, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_ShowDatabases, Columns: yyDollar[3].val.([]string)} } case 224: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1704 +//line sql3.y:1563 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_ShowView, Columns: yyDollar[3].strs} + yyVAL.val = Privilege{Type: PrivilegeType_ShowView, Columns: yyDollar[3].val.([]string)} } case 225: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1708 +//line sql3.y:1567 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Shutdown, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Shutdown, Columns: yyDollar[2].val.([]string)} } case 226: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1712 +//line sql3.y:1571 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Super, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Super, Columns: yyDollar[2].val.([]string)} } case 227: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1716 +//line sql3.y:1575 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Trigger, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Trigger, Columns: yyDollar[2].val.([]string)} } case 228: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1720 +//line sql3.y:1579 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Update, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Update, Columns: yyDollar[2].val.([]string)} } case 229: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1724 +//line sql3.y:1583 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Usage, Columns: yyDollar[2].strs} + yyVAL.val = Privilege{Type: PrivilegeType_Usage, Columns: yyDollar[2].val.([]string)} } case 230: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1728 +//line sql3.y:1587 { - yyVAL.grantPrivilege = Privilege{Type: PrivilegeType_Dynamic, DynamicName: strings.ToLower(string(yyDollar[1].bytes))} + yyVAL.val = Privilege{Type: PrivilegeType_Dynamic, DynamicName: strings.ToLower(string(yyDollar[1].bytes))} } case 231: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1734 +//line sql3.y:1593 { - yyVAL.grantPrivileges = []Privilege{yyDollar[1].grantPrivilege} + yyVAL.val = []Privilege{yyDollar[1].val.(Privilege)} } case 232: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1738 +//line sql3.y:1597 { - yyVAL.grantPrivileges = append(yyDollar[1].grantPrivileges, yyDollar[3].grantPrivilege) + yyVAL.val = append(yyDollar[1].val.([]Privilege), yyDollar[3].val.(Privilege)) } case 272: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1784 +//line sql3.y:1643 { - yyVAL.strs = nil + yyVAL.val = []string(nil) } case 273: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1788 +//line sql3.y:1647 { - yyVAL.strs = yyDollar[2].strs + yyVAL.val = yyDollar[2].val.([]string) } case 274: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1794 +//line sql3.y:1653 { - yyVAL.strs = []string{yyDollar[1].colIdent.String()} + yyVAL.val = []string{yyDollar[1].val.(ColIdent).String()} } case 275: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1798 +//line sql3.y:1657 { - yyVAL.strs = append(yyDollar[1].strs, yyDollar[3].colIdent.String()) + yyVAL.val = append(yyDollar[1].val.([]string), yyDollar[3].val.(ColIdent).String()) } case 276: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1803 +//line sql3.y:1662 { - yyVAL.grantObjectType = GrantObjectType_Any + yyVAL.val = GrantObjectType_Any } case 277: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1807 +//line sql3.y:1666 { - yyVAL.grantObjectType = GrantObjectType_Table + yyVAL.val = GrantObjectType_Table } case 278: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1811 +//line sql3.y:1670 { - yyVAL.grantObjectType = GrantObjectType_Function + yyVAL.val = GrantObjectType_Function } case 279: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1815 +//line sql3.y:1674 { - yyVAL.grantObjectType = GrantObjectType_Procedure + yyVAL.val = GrantObjectType_Procedure } case 280: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1821 +//line sql3.y:1680 { - yyVAL.privilegeLevel = PrivilegeLevel{Database: "", TableRoutine: "*"} + yyVAL.val = PrivilegeLevel{Database: "", TableRoutine: "*"} } case 281: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1825 +//line sql3.y:1684 { - yyVAL.privilegeLevel = PrivilegeLevel{Database: "*", TableRoutine: "*"} + yyVAL.val = PrivilegeLevel{Database: "*", TableRoutine: "*"} } case 282: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1829 +//line sql3.y:1688 { - yyVAL.privilegeLevel = PrivilegeLevel{Database: "", TableRoutine: yyDollar[1].colIdent.String()} + yyVAL.val = PrivilegeLevel{Database: "", TableRoutine: yyDollar[1].val.(ColIdent).String()} } case 283: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1833 +//line sql3.y:1692 { - yyVAL.privilegeLevel = PrivilegeLevel{Database: yyDollar[1].colIdent.String(), TableRoutine: "*"} + yyVAL.val = PrivilegeLevel{Database: yyDollar[1].val.(ColIdent).String(), TableRoutine: "*"} } case 284: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1837 +//line sql3.y:1696 { - yyVAL.privilegeLevel = PrivilegeLevel{Database: yyDollar[1].colIdent.String(), TableRoutine: yyDollar[3].colIdent.String()} + yyVAL.val = PrivilegeLevel{Database: yyDollar[1].val.(ColIdent).String(), TableRoutine: yyDollar[3].val.(ColIdent).String()} } case 285: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1842 +//line sql3.y:1701 { - yyVAL.grantAssumption = nil + yyVAL.val = &GrantUserAssumption{} } case 286: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1846 +//line sql3.y:1705 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_Default, User: yyDollar[2].accountName, Roles: nil} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_Default, User: yyDollar[2].val.(AccountName), Roles: nil} } case 287: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1850 +//line sql3.y:1709 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_Default, User: yyDollar[2].accountName, Roles: nil} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_Default, User: yyDollar[2].val.(AccountName), Roles: nil} } case 288: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1854 +//line sql3.y:1713 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_None, User: yyDollar[2].accountName, Roles: nil} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_None, User: yyDollar[2].val.(AccountName), Roles: nil} } case 289: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1858 +//line sql3.y:1717 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_All, User: yyDollar[2].accountName, Roles: nil} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_All, User: yyDollar[2].val.(AccountName), Roles: nil} } case 290: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:1862 +//line sql3.y:1721 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_AllExcept, User: yyDollar[2].accountName, Roles: yyDollar[7].accountNames} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_AllExcept, User: yyDollar[2].val.(AccountName), Roles: yyDollar[7].val.([]AccountName)} } case 291: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:1866 +//line sql3.y:1725 { - yyVAL.grantAssumption = &GrantUserAssumption{Type: GrantUserAssumptionType_Roles, User: yyDollar[2].accountName, Roles: yyDollar[5].accountNames} + yyVAL.val = &GrantUserAssumption{Type: GrantUserAssumptionType_Roles, User: yyDollar[2].val.(AccountName), Roles: yyDollar[5].val.([]AccountName)} } case 292: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1871 +//line sql3.y:1730 { - yyVAL.boolean = false + yyVAL.val = false } case 293: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1875 +//line sql3.y:1734 { - yyVAL.boolean = true + yyVAL.val = true } case 294: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1880 +//line sql3.y:1739 { - yyVAL.boolean = false + yyVAL.val = false } case 295: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1884 +//line sql3.y:1743 { - yyVAL.boolean = true + yyVAL.val = true } case 296: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1891 +//line sql3.y:1750 { - if yyDollar[1].selStmt.GetInto() != nil { + if yyDollar[1].val.(SelectStatement).GetInto() != nil { yylex.Error(fmt.Errorf("INTO clause is not allowed").Error()) return 1 } - yyDollar[1].selStmt.SetOrderBy(yyDollar[2].orderBy) - yyDollar[1].selStmt.SetLimit(yyDollar[3].limit) - yyDollar[1].selStmt.SetLock(yyDollar[4].str) - yyVAL.selStmt = yyDollar[1].selStmt + yyDollar[1].val.(SelectStatement).SetOrderBy(yyDollar[2].val.(OrderBy)) + yyDollar[1].val.(SelectStatement).SetLimit(yyDollar[3].val.(*Limit)) + yyDollar[1].val.(SelectStatement).SetLock(yyDollar[4].val.(string)) + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 297: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:1904 +//line sql3.y:1763 { - if yyDollar[1].selStmt.GetInto() != nil { + if yyDollar[1].val.(SelectStatement).GetInto() != nil { yylex.Error(fmt.Errorf("INTO clause is not allowed").Error()) return 1 } - yyDollar[1].selStmt.SetOrderBy(yyDollar[2].orderBy) - yyDollar[1].selStmt.SetLimit(yyDollar[3].limit) - yyDollar[1].selStmt.SetLock(yyDollar[4].str) - yyVAL.selStmt = yyDollar[1].selStmt + yyDollar[1].val.(SelectStatement).SetOrderBy(yyDollar[2].val.(OrderBy)) + yyDollar[1].val.(SelectStatement).SetLimit(yyDollar[3].val.(*Limit)) + yyDollar[1].val.(SelectStatement).SetLock(yyDollar[4].val.(string)) + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 298: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1916 +//line sql3.y:1775 { - yyVAL.procedureParams = nil + yyVAL.val = []ProcedureParam(nil) } case 299: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1920 +//line sql3.y:1779 { - yyVAL.procedureParams = yyDollar[1].procedureParams + yyVAL.val = yyDollar[1].val.([]ProcedureParam) } case 300: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1926 +//line sql3.y:1785 { - yyVAL.procedureParams = []ProcedureParam{yyDollar[1].procedureParam} + yyVAL.val = []ProcedureParam{yyDollar[1].val.(ProcedureParam)} } case 301: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1930 +//line sql3.y:1789 { - yyVAL.procedureParams = append(yyVAL.procedureParams, yyDollar[3].procedureParam) + yyVAL.val = append(yyVAL.val.([]ProcedureParam), yyDollar[3].val.(ProcedureParam)) } case 302: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1936 +//line sql3.y:1795 { - yyVAL.procedureParam = ProcedureParam{Direction: ProcedureParamDirection_In, Name: yyDollar[1].colIdent.String(), Type: yyDollar[2].columnType} + yyVAL.val = ProcedureParam{Direction: ProcedureParamDirection_In, Name: yyDollar[1].val.(ColIdent).String(), Type: yyDollar[2].val.(ColumnType)} } case 303: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1940 +//line sql3.y:1799 { - yyVAL.procedureParam = ProcedureParam{Direction: ProcedureParamDirection_In, Name: yyDollar[2].colIdent.String(), Type: yyDollar[3].columnType} + yyVAL.val = ProcedureParam{Direction: ProcedureParamDirection_In, Name: yyDollar[2].val.(ColIdent).String(), Type: yyDollar[3].val.(ColumnType)} } case 304: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1944 +//line sql3.y:1803 { - yyVAL.procedureParam = ProcedureParam{Direction: ProcedureParamDirection_Inout, Name: yyDollar[2].colIdent.String(), Type: yyDollar[3].columnType} + yyVAL.val = ProcedureParam{Direction: ProcedureParamDirection_Inout, Name: yyDollar[2].val.(ColIdent).String(), Type: yyDollar[3].val.(ColumnType)} } case 305: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1948 +//line sql3.y:1807 { - yyVAL.procedureParam = ProcedureParam{Direction: ProcedureParamDirection_Out, Name: yyDollar[2].colIdent.String(), Type: yyDollar[3].columnType} + yyVAL.val = ProcedureParam{Direction: ProcedureParamDirection_Out, Name: yyDollar[2].val.(ColIdent).String(), Type: yyDollar[3].val.(ColumnType)} } case 306: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:1953 +//line sql3.y:1812 { - yyVAL.characteristics = nil + yyVAL.val = []Characteristic(nil) } case 307: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1957 +//line sql3.y:1816 { - yyVAL.characteristics = yyDollar[1].characteristics + yyVAL.val = yyDollar[1].val.([]Characteristic) } case 308: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1963 +//line sql3.y:1822 { - yyVAL.characteristics = []Characteristic{yyDollar[1].characteristic} + yyVAL.val = []Characteristic{yyDollar[1].val.(Characteristic)} } case 309: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1967 +//line sql3.y:1826 { - yyVAL.characteristics = append(yyVAL.characteristics, yyDollar[2].characteristic) + yyVAL.val = append(yyVAL.val.([]Characteristic), yyDollar[2].val.(Characteristic)) } case 310: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1973 +//line sql3.y:1832 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_Comment, Comment: string(yyDollar[2].bytes)} + yyVAL.val = Characteristic{Type: CharacteristicValue_Comment, Comment: string(yyDollar[2].bytes)} } case 311: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1977 +//line sql3.y:1836 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_LanguageSql} + yyVAL.val = Characteristic{Type: CharacteristicValue_LanguageSql} } case 312: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1981 +//line sql3.y:1840 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_NotDeterministic} + yyVAL.val = Characteristic{Type: CharacteristicValue_NotDeterministic} } case 313: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:1985 +//line sql3.y:1844 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_Deterministic} + yyVAL.val = Characteristic{Type: CharacteristicValue_Deterministic} } case 314: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1989 +//line sql3.y:1848 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_ContainsSql} + yyVAL.val = Characteristic{Type: CharacteristicValue_ContainsSql} } case 315: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:1993 +//line sql3.y:1852 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_NoSql} + yyVAL.val = Characteristic{Type: CharacteristicValue_NoSql} } case 316: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:1997 +//line sql3.y:1856 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_ReadsSqlData} + yyVAL.val = Characteristic{Type: CharacteristicValue_ReadsSqlData} } case 317: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2001 +//line sql3.y:1860 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_ModifiesSqlData} + yyVAL.val = Characteristic{Type: CharacteristicValue_ModifiesSqlData} } case 318: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2005 +//line sql3.y:1864 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_SqlSecurityDefiner} + yyVAL.val = Characteristic{Type: CharacteristicValue_SqlSecurityDefiner} } case 319: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2009 +//line sql3.y:1868 { - yyVAL.characteristic = Characteristic{Type: CharacteristicValue_SqlSecurityInvoker} + yyVAL.val = Characteristic{Type: CharacteristicValue_SqlSecurityInvoker} } case 320: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2015 +//line sql3.y:1874 { - yyVAL.statement = &BeginEndBlock{Label: ""} + yyVAL.val = &BeginEndBlock{Label: ""} } case 321: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2019 +//line sql3.y:1878 { - yyVAL.statement = &BeginEndBlock{Label: string(yyDollar[1].bytes)} + yyVAL.val = &BeginEndBlock{Label: string(yyDollar[1].bytes)} } case 322: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2023 +//line sql3.y:1882 { label := string(yyDollar[1].bytes) if label != string(yyDollar[5].bytes) { yylex.Error("End-label " + string(yyDollar[5].bytes) + " without match") return 1 } - yyVAL.statement = &BeginEndBlock{Label: label} + yyVAL.val = &BeginEndBlock{Label: label} } case 323: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2032 +//line sql3.y:1891 { - yyVAL.statement = &BeginEndBlock{Label: "", Statements: yyDollar[2].statements} + yyVAL.val = &BeginEndBlock{Label: "", Statements: yyDollar[2].val.(Statements)} } case 324: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:2036 +//line sql3.y:1895 { - yyVAL.statement = &BeginEndBlock{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].statements} + yyVAL.val = &BeginEndBlock{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].val.(Statements)} } case 325: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2040 +//line sql3.y:1899 { label := string(yyDollar[1].bytes) if label != string(yyDollar[7].bytes) { yylex.Error("End-label " + string(yyDollar[7].bytes) + " without match") return 1 } - yyVAL.statement = &BeginEndBlock{Label: label, Statements: yyDollar[4].statements} + yyVAL.val = &BeginEndBlock{Label: label, Statements: yyDollar[4].val.(Statements)} } case 326: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2051 +//line sql3.y:1910 { - yyVAL.viewSpec = &ViewSpec{Algorithm: "", Definer: yyDollar[1].str, Security: yyDollar[2].str} + yyVAL.val = &ViewSpec{Algorithm: "", Definer: yyDollar[1].val.(string), Security: yyDollar[2].val.(string)} } case 327: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2055 +//line sql3.y:1914 { - yyVAL.viewSpec = &ViewSpec{Algorithm: yyDollar[1].str, Definer: yyDollar[2].str, Security: yyDollar[3].str} + yyVAL.val = &ViewSpec{Algorithm: yyDollar[1].val.(string), Definer: yyDollar[2].val.(string), Security: yyDollar[3].val.(string)} } case 328: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2061 +//line sql3.y:1920 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 329: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2065 +//line sql3.y:1924 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 330: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2069 +//line sql3.y:1928 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 331: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2074 +//line sql3.y:1933 { - yyVAL.str = "" + yyVAL.val = "" } case 332: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2078 +//line sql3.y:1937 { - yyVAL.str = yyDollar[3].accountName.String() + yyVAL.val = yyDollar[3].val.(AccountName).String() } case 333: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2083 +//line sql3.y:1942 { - yyVAL.str = "" + yyVAL.val = "" } case 334: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2087 +//line sql3.y:1946 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 335: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2091 +//line sql3.y:1950 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 336: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2097 +//line sql3.y:1956 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 337: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2101 +//line sql3.y:1960 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 338: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2105 +//line sql3.y:1964 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 339: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2111 +//line sql3.y:1970 { anyHost := false - if yyDollar[3].str == "%" { + if yyDollar[3].val.(string) == "%" { anyHost = true } - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: yyDollar[3].str, AnyHost: anyHost} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: yyDollar[3].val.(string), AnyHost: anyHost} } case 340: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2119 +//line sql3.y:1978 { - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: "", AnyHost: false} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: "", AnyHost: false} } case 341: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2123 +//line sql3.y:1982 { - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: "", AnyHost: true} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: "", AnyHost: true} } case 342: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2129 +//line sql3.y:1988 { - yyVAL.accountNames = []AccountName{yyDollar[1].accountName} + yyVAL.val = []AccountName{yyDollar[1].val.(AccountName)} } case 343: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2133 +//line sql3.y:1992 { - yyVAL.accountNames = append(yyDollar[1].accountNames, yyDollar[3].accountName) + yyVAL.val = append(yyDollar[1].val.([]AccountName), yyDollar[3].val.(AccountName)) } case 344: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2139 +//line sql3.y:1998 { - if len(yyDollar[1].str) == 0 { + if len(yyDollar[1].val.(string)) == 0 { yylex.Error("the anonymous user is not a valid role name") return 1 } - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: yyDollar[3].str, AnyHost: false} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: yyDollar[3].val.(string), AnyHost: false} } case 345: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2147 +//line sql3.y:2006 { - if len(yyDollar[1].str) == 0 { + if len(yyDollar[1].val.(string)) == 0 { yylex.Error("the anonymous user is not a valid role name") return 1 } - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: "", AnyHost: false} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: "", AnyHost: false} } case 346: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2155 +//line sql3.y:2014 { - if len(yyDollar[1].str) == 0 { + if len(yyDollar[1].val.(string)) == 0 { yylex.Error("the anonymous user is not a valid role name") return 1 } - yyVAL.accountName = AccountName{Name: yyDollar[1].str, Host: "", AnyHost: true} + yyVAL.val = AccountName{Name: yyDollar[1].val.(string), Host: "", AnyHost: true} } case 347: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2165 +//line sql3.y:2024 { - yyVAL.accountNames = []AccountName{yyDollar[1].accountName} + yyVAL.val = []AccountName{yyDollar[1].val.(AccountName)} } case 348: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2169 +//line sql3.y:2028 { - yyVAL.accountNames = append(yyDollar[1].accountNames, yyDollar[3].accountName) + yyVAL.val = append(yyDollar[1].val.([]AccountName), yyDollar[3].val.(AccountName)) } case 349: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2175 +//line sql3.y:2034 { - yyVAL.accountWithAuth = AccountWithAuth{AccountName: yyDollar[1].accountName} + yyVAL.val = AccountWithAuth{AccountName: yyDollar[1].val.(AccountName)} } case 350: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2179 +//line sql3.y:2038 { - yyVAL.accountWithAuth = AccountWithAuth{AccountName: yyDollar[1].accountName, Auth1: yyDollar[2].authentication} + yyVAL.val = AccountWithAuth{AccountName: yyDollar[1].val.(AccountName), Auth1: yyDollar[2].val.(*Authentication)} } case 351: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2183 +//line sql3.y:2042 { - yyVAL.accountWithAuth = AccountWithAuth{AccountName: yyDollar[1].accountName, Auth1: yyDollar[2].authentication, AuthInitial: yyDollar[5].authentication} + yyVAL.val = AccountWithAuth{AccountName: yyDollar[1].val.(AccountName), Auth1: yyDollar[2].val.(*Authentication), AuthInitial: yyDollar[5].val.(*Authentication)} } case 352: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2187 +//line sql3.y:2046 { - yyVAL.accountWithAuth = AccountWithAuth{AccountName: yyDollar[1].accountName, Auth1: yyDollar[2].authentication, Auth2: yyDollar[4].authentication} + yyVAL.val = AccountWithAuth{AccountName: yyDollar[1].val.(AccountName), Auth1: yyDollar[2].val.(*Authentication), Auth2: yyDollar[4].val.(*Authentication)} } case 353: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:2191 +//line sql3.y:2050 { - yyVAL.accountWithAuth = AccountWithAuth{AccountName: yyDollar[1].accountName, Auth1: yyDollar[2].authentication, Auth2: yyDollar[4].authentication, Auth3: yyDollar[6].authentication} + yyVAL.val = AccountWithAuth{AccountName: yyDollar[1].val.(AccountName), Auth1: yyDollar[2].val.(*Authentication), Auth2: yyDollar[4].val.(*Authentication), Auth3: yyDollar[6].val.(*Authentication)} } case 354: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2197 +//line sql3.y:2056 { - yyVAL.authentication = &Authentication{RandomPassword: true} + yyVAL.val = &Authentication{RandomPassword: true} } case 355: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2201 +//line sql3.y:2060 { - yyVAL.authentication = &Authentication{Password: string(yyDollar[3].bytes)} + yyVAL.val = &Authentication{Password: string(yyDollar[3].bytes)} } case 356: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2205 +//line sql3.y:2064 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes)} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes)} } case 357: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:2209 +//line sql3.y:2068 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes), RandomPassword: true} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes), RandomPassword: true} } case 358: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2213 +//line sql3.y:2072 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes), Password: string(yyDollar[5].bytes)} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes), Password: string(yyDollar[5].bytes)} } case 359: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2217 +//line sql3.y:2076 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} } case 360: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2221 +//line sql3.y:2080 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} } case 361: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2227 +//line sql3.y:2086 { - yyVAL.authentication = &Authentication{RandomPassword: true} + yyVAL.val = &Authentication{RandomPassword: true} } case 362: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2231 +//line sql3.y:2090 { - yyVAL.authentication = &Authentication{Password: string(yyDollar[3].bytes)} + yyVAL.val = &Authentication{Password: string(yyDollar[3].bytes)} } case 363: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2235 +//line sql3.y:2094 { - yyVAL.authentication = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} + yyVAL.val = &Authentication{Plugin: string(yyDollar[3].bytes), Identity: string(yyDollar[5].bytes)} } case 364: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2241 +//line sql3.y:2100 { - yyVAL.accountsWithAuth = []AccountWithAuth{yyDollar[1].accountWithAuth} + yyVAL.val = []AccountWithAuth{yyDollar[1].val.(AccountWithAuth)} } case 365: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2245 +//line sql3.y:2104 { - yyVAL.accountsWithAuth = append(yyDollar[1].accountsWithAuth, yyDollar[3].accountWithAuth) + yyVAL.val = append(yyDollar[1].val.([]AccountWithAuth), yyDollar[3].val.(AccountWithAuth)) } case 366: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2251 +//line sql3.y:2110 { - yyVAL.eventName = EventName{Name: yyDollar[1].colIdent} + yyVAL.val = EventName{Name: yyDollar[1].val.(ColIdent)} } case 367: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2255 +//line sql3.y:2114 { - yyVAL.eventName = EventName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].colIdent} + yyVAL.val = EventName{Qualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(ColIdent)} } case 368: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2261 +//line sql3.y:2120 { - yyVAL.eventScheduleSpec = &EventScheduleSpec{At: &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].expr, EventIntervals: yyDollar[3].intervalExprs}} + yyVAL.val = &EventScheduleSpec{At: &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].val.(Expr), EventIntervals: yyDollar[3].val.([]IntervalExpr)}} } case 369: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2265 +//line sql3.y:2124 { - yyVAL.eventScheduleSpec = &EventScheduleSpec{EveryInterval: IntervalExpr{Expr: yyDollar[2].expr, Unit: string(yyDollar[3].bytes)}, Starts: yyDollar[4].eventScheduleTimeSpec, Ends: yyDollar[5].eventScheduleTimeSpec} + yyVAL.val = &EventScheduleSpec{EveryInterval: IntervalExpr{Expr: yyDollar[2].val.(Expr), Unit: string(yyDollar[3].bytes)}, Starts: yyDollar[4].val.(*EventScheduleTimeSpec), Ends: yyDollar[5].val.(*EventScheduleTimeSpec)} } case 370: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2270 +//line sql3.y:2129 { - yyVAL.intervalExprs = []IntervalExpr{} + yyVAL.val = []IntervalExpr{} } case 371: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2274 +//line sql3.y:2133 { - yyVAL.intervalExprs = append(yyDollar[1].intervalExprs, IntervalExpr{Expr: yyDollar[4].expr, Unit: string(yyDollar[5].bytes)}) + yyVAL.val = append(yyDollar[1].val.([]IntervalExpr), IntervalExpr{Expr: yyDollar[4].val.(Expr), Unit: string(yyDollar[5].bytes)}) } case 372: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2279 +//line sql3.y:2138 { - yyVAL.eventScheduleTimeSpec = nil + yyVAL.val = &EventScheduleTimeSpec{} } case 373: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2283 +//line sql3.y:2142 { - yyVAL.eventScheduleTimeSpec = &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].expr, EventIntervals: yyDollar[3].intervalExprs} + yyVAL.val = &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].val.(Expr), EventIntervals: yyDollar[3].val.([]IntervalExpr)} } case 374: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2288 +//line sql3.y:2147 { - yyVAL.eventScheduleTimeSpec = nil + yyVAL.val = &EventScheduleTimeSpec{} } case 375: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2292 +//line sql3.y:2151 { - yyVAL.eventScheduleTimeSpec = &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].expr, EventIntervals: yyDollar[3].intervalExprs} + yyVAL.val = &EventScheduleTimeSpec{EventTimestamp: yyDollar[2].val.(Expr), EventIntervals: yyDollar[3].val.([]IntervalExpr)} } case 376: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2297 +//line sql3.y:2156 { - yyVAL.eventOnCompletion = EventOnCompletion_Undefined + yyVAL.val = EventOnCompletion_Undefined } case 377: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2301 +//line sql3.y:2160 { - yyVAL.eventOnCompletion = EventOnCompletion_Preserve + yyVAL.val = EventOnCompletion_Preserve } case 378: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2305 +//line sql3.y:2164 { - yyVAL.eventOnCompletion = EventOnCompletion_NotPreserve + yyVAL.val = EventOnCompletion_NotPreserve } case 379: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2310 +//line sql3.y:2169 { - yyVAL.eventStatus = EventStatus_Undefined + yyVAL.val = EventStatus_Undefined } case 380: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2314 +//line sql3.y:2173 { - yyVAL.eventStatus = EventStatus_Enable + yyVAL.val = EventStatus_Enable } case 381: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2318 +//line sql3.y:2177 { - yyVAL.eventStatus = EventStatus_Disable + yyVAL.val = EventStatus_Disable } case 382: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2322 +//line sql3.y:2181 { - yyVAL.eventStatus = EventStatus_DisableOnSlave + yyVAL.val = EventStatus_DisableOnSlave } case 383: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2327 +//line sql3.y:2186 { - yyVAL.sqlVal = nil + yyVAL.val = &SQLVal{} } case 384: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2331 +//line sql3.y:2190 { - yyVAL.sqlVal = NewStrVal(yyDollar[2].bytes) + yyVAL.val = NewStrVal(yyDollar[2].bytes) } case 385: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2337 +//line sql3.y:2196 { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = yyDollar[1].val.(Expr) } case 386: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2341 +//line sql3.y:2200 { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = yyDollar[1].val.(Expr) } case 387: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2347 +//line sql3.y:2206 { - yyVAL.str = BeforeStr + yyVAL.val = BeforeStr } case 388: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2351 +//line sql3.y:2210 { - yyVAL.str = AfterStr + yyVAL.val = AfterStr } case 389: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2357 +//line sql3.y:2216 { - yyVAL.str = InsertStr + yyVAL.val = InsertStr } case 390: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2361 +//line sql3.y:2220 { - yyVAL.str = UpdateStr + yyVAL.val = UpdateStr } case 391: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2365 +//line sql3.y:2224 { - yyVAL.str = DeleteStr + yyVAL.val = DeleteStr } case 392: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2370 +//line sql3.y:2229 { - yyVAL.triggerOrder = nil + yyVAL.val = &TriggerOrder{} } case 393: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2374 +//line sql3.y:2233 { - yyVAL.triggerOrder = &TriggerOrder{PrecedesOrFollows: FollowsStr, OtherTriggerName: string(yyDollar[2].bytes)} + yyVAL.val = &TriggerOrder{PrecedesOrFollows: FollowsStr, OtherTriggerName: string(yyDollar[2].bytes)} } case 394: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2378 +//line sql3.y:2237 { - yyVAL.triggerOrder = &TriggerOrder{PrecedesOrFollows: PrecedesStr, OtherTriggerName: string(yyDollar[2].bytes)} + yyVAL.val = &TriggerOrder{PrecedesOrFollows: PrecedesStr, OtherTriggerName: string(yyDollar[2].bytes)} } case 395: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2384 +//line sql3.y:2243 { - yyVAL.statement = yyDollar[1].statement + yyVAL.val = yyDollar[1].val.(Statement) } case 401: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2395 +//line sql3.y:2254 { - yyVAL.statement = &BeginEndBlock{Statements: yyDollar[2].statements} + yyVAL.val = &BeginEndBlock{Statements: yyDollar[2].val.(Statements)} } case 402: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2399 +//line sql3.y:2258 { - yyVAL.statement = &BeginEndBlock{} + yyVAL.val = &BeginEndBlock{} } case 403: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2405 +//line sql3.y:2264 { - yyVAL.statement = &CaseStatement{Expr: yyDollar[2].expr, Cases: yyDollar[3].caseStatementCases} + yyVAL.val = &CaseStatement{Expr: yyDollar[2].val.(Expr), Cases: yyDollar[3].val.([]CaseStatementCase)} } case 404: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:2409 +//line sql3.y:2268 { - yyVAL.statement = &CaseStatement{Expr: yyDollar[2].expr, Cases: yyDollar[3].caseStatementCases, Else: yyDollar[5].statements} + yyVAL.val = &CaseStatement{Expr: yyDollar[2].val.(Expr), Cases: yyDollar[3].val.([]CaseStatementCase), Else: yyDollar[5].val.(Statements)} } case 405: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2413 +//line sql3.y:2272 { - yyVAL.statement = &CaseStatement{Expr: nil, Cases: yyDollar[2].caseStatementCases} + yyVAL.val = &CaseStatement{Expr: nil, Cases: yyDollar[2].val.([]CaseStatementCase)} } case 406: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2417 +//line sql3.y:2276 { - yyVAL.statement = &CaseStatement{Expr: nil, Cases: yyDollar[2].caseStatementCases, Else: yyDollar[4].statements} + yyVAL.val = &CaseStatement{Expr: nil, Cases: yyDollar[2].val.([]CaseStatementCase), Else: yyDollar[4].val.(Statements)} } case 407: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2423 +//line sql3.y:2282 { - yyVAL.caseStatementCases = []CaseStatementCase{yyDollar[1].caseStatementCase} + yyVAL.val = []CaseStatementCase{yyDollar[1].val.(CaseStatementCase)} } case 408: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2427 +//line sql3.y:2286 { - yyVAL.caseStatementCases = append(yyVAL.caseStatementCases, yyDollar[2].caseStatementCase) + yyVAL.val = append(yyVAL.val.([]CaseStatementCase), yyDollar[2].val.(CaseStatementCase)) } case 409: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2433 +//line sql3.y:2292 { - yyVAL.caseStatementCase = CaseStatementCase{Case: yyDollar[2].expr, Statements: yyDollar[4].statements} + yyVAL.val = CaseStatementCase{Case: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)} } case 410: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2439 +//line sql3.y:2298 { - conds := []IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].expr, Statements: yyDollar[4].statements}} - yyVAL.statement = &IfStatement{Conditions: conds} + conds := []IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)}} + yyVAL.val = &IfStatement{Conditions: conds} } case 411: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:2444 +//line sql3.y:2303 { - conds := []IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].expr, Statements: yyDollar[4].statements}} - yyVAL.statement = &IfStatement{Conditions: conds, Else: yyDollar[7].statements} + conds := []IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)}} + yyVAL.val = &IfStatement{Conditions: conds, Else: yyDollar[7].val.(Statements)} } case 412: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:2449 +//line sql3.y:2308 { - conds := yyDollar[6].ifStatementConditions - conds = append([]IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].expr, Statements: yyDollar[4].statements}}, conds...) - yyVAL.statement = &IfStatement{Conditions: conds} + conds := yyDollar[6].val.([]IfStatementCondition) + conds = append([]IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)}}, conds...) + yyVAL.val = &IfStatement{Conditions: conds} } case 413: yyDollar = yyS[yypt-11 : yypt+1] -//line sql.y:2455 +//line sql3.y:2314 { - conds := yyDollar[6].ifStatementConditions - conds = append([]IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].expr, Statements: yyDollar[4].statements}}, conds...) - yyVAL.statement = &IfStatement{Conditions: conds, Else: yyDollar[8].statements} + conds := yyDollar[6].val.([]IfStatementCondition) + conds = append([]IfStatementCondition{IfStatementCondition{Expr: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)}}, conds...) + yyVAL.val = &IfStatement{Conditions: conds, Else: yyDollar[8].val.(Statements)} } case 414: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2463 +//line sql3.y:2322 { - yyVAL.ifStatementConditions = []IfStatementCondition{yyDollar[1].ifStatementCondition} + yyVAL.val = []IfStatementCondition{yyDollar[1].val.(IfStatementCondition)} } case 415: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2467 +//line sql3.y:2326 { - yyVAL.ifStatementConditions = append(yyVAL.ifStatementConditions, yyDollar[2].ifStatementCondition) + yyVAL.val = append(yyVAL.val.([]IfStatementCondition), yyDollar[2].val.(IfStatementCondition)) } case 416: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2473 +//line sql3.y:2332 { - yyVAL.ifStatementCondition = IfStatementCondition{Expr: yyDollar[2].expr, Statements: yyDollar[4].statements} + yyVAL.val = IfStatementCondition{Expr: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)} } case 417: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2479 +//line sql3.y:2338 { - yyVAL.statement = &Declare{Condition: &DeclareCondition{Name: string(yyDollar[2].bytes), SqlStateValue: string(yyDollar[5].bytes)}} + yyVAL.val = &Declare{Condition: &DeclareCondition{Name: string(yyDollar[2].bytes), SqlStateValue: string(yyDollar[5].bytes)}} } case 418: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2483 +//line sql3.y:2342 { - yyVAL.statement = &Declare{Condition: &DeclareCondition{Name: string(yyDollar[2].bytes), MysqlErrorCode: NewIntVal(yyDollar[5].bytes)}} + yyVAL.val = &Declare{Condition: &DeclareCondition{Name: string(yyDollar[2].bytes), MysqlErrorCode: NewIntVal(yyDollar[5].bytes)}} } case 419: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2487 +//line sql3.y:2346 { - yyVAL.statement = &Declare{Cursor: &DeclareCursor{Name: string(yyDollar[2].bytes), SelectStmt: yyDollar[5].selStmt}} + yyVAL.val = &Declare{Cursor: &DeclareCursor{Name: string(yyDollar[2].bytes), SelectStmt: yyDollar[5].val.(SelectStatement)}} } case 420: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:2491 +//line sql3.y:2350 { - yyVAL.statement = &Declare{Handler: &DeclareHandler{Action: yyDollar[2].declareHandlerAction, ConditionValues: yyDollar[5].declareHandlerConditions, Statement: yyDollar[6].statement}} + yyVAL.val = &Declare{Handler: &DeclareHandler{Action: yyDollar[2].val.(DeclareHandlerAction), ConditionValues: yyDollar[5].val.([]DeclareHandlerCondition), Statement: yyDollar[6].val.(Statement)}} } case 421: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2495 +//line sql3.y:2354 { - yyDollar[3].columnType.Charset = yyDollar[4].str - yyDollar[3].columnType.Collate = yyDollar[5].str - yyVAL.statement = &Declare{Variables: &DeclareVariables{Names: yyDollar[2].colIdents, VarType: yyDollar[3].columnType}} + var ct ColumnType + ct = yyDollar[3].val.(ColumnType) + ct.Charset = yyDollar[4].val.(string) + ct.Collate = yyDollar[5].val.(string) + yyVAL.val = &Declare{Variables: &DeclareVariables{Names: yyDollar[2].val.([]ColIdent), VarType: ct}} } case 422: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2501 +//line sql3.y:2362 { - yyDollar[3].columnType.Charset = yyDollar[4].str - yyDollar[3].columnType.Collate = yyDollar[5].str - yyDollar[3].columnType.Default = yyDollar[7].expr - yyVAL.statement = &Declare{Variables: &DeclareVariables{Names: yyDollar[2].colIdents, VarType: yyDollar[3].columnType}} + ct := yyDollar[3].val.(ColumnType) + ct.Charset = yyDollar[4].val.(string) + ct.Collate = yyDollar[5].val.(string) + ct.Default = yyDollar[7].val.(Expr) + yyVAL.val = &Declare{Variables: &DeclareVariables{Names: yyDollar[2].val.([]ColIdent), VarType: ct}} } case 423: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2510 +//line sql3.y:2372 { - yyVAL.declareHandlerAction = DeclareHandlerAction_Continue + yyVAL.val = DeclareHandlerAction_Continue } case 424: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2514 +//line sql3.y:2376 { - yyVAL.declareHandlerAction = DeclareHandlerAction_Exit + yyVAL.val = DeclareHandlerAction_Exit } case 425: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2518 +//line sql3.y:2380 { - yyVAL.declareHandlerAction = DeclareHandlerAction_Undo + yyVAL.val = DeclareHandlerAction_Undo } case 426: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2524 +//line sql3.y:2386 { - yyVAL.declareHandlerConditions = []DeclareHandlerCondition{yyDollar[1].declareHandlerCondition} + yyVAL.val = []DeclareHandlerCondition{yyDollar[1].val.(DeclareHandlerCondition)} } case 427: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2528 +//line sql3.y:2390 { - yyVAL.declareHandlerConditions = append(yyVAL.declareHandlerConditions, yyDollar[3].declareHandlerCondition) + yyVAL.val = append(yyVAL.val.([]DeclareHandlerCondition), yyDollar[3].val.(DeclareHandlerCondition)) } case 428: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2534 +//line sql3.y:2396 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_MysqlErrorCode, MysqlErrorCode: NewIntVal(yyDollar[1].bytes)} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_MysqlErrorCode, MysqlErrorCode: NewIntVal(yyDollar[1].bytes)} } case 429: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2538 +//line sql3.y:2400 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlState, String: string(yyDollar[1].bytes)} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlState, String: string(yyDollar[1].bytes)} } case 430: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2542 +//line sql3.y:2404 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlWarning} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlWarning} } case 431: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2546 +//line sql3.y:2408 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_NotFound} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_NotFound} } case 432: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2550 +//line sql3.y:2412 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlException} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_SqlException} } case 433: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2554 +//line sql3.y:2416 { - yyVAL.declareHandlerCondition = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_ConditionName, String: string(yyDollar[1].bytes)} + yyVAL.val = DeclareHandlerCondition{ValueType: DeclareHandlerCondition_ConditionName, String: string(yyDollar[1].bytes)} } case 434: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2560 +//line sql3.y:2422 { - yyVAL.statement = &OpenCursor{Name: string(yyDollar[2].bytes)} + yyVAL.val = &OpenCursor{Name: string(yyDollar[2].bytes)} } case 435: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2566 +//line sql3.y:2428 { - yyVAL.statement = &CloseCursor{Name: string(yyDollar[2].bytes)} + yyVAL.val = &CloseCursor{Name: string(yyDollar[2].bytes)} } case 436: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2572 +//line sql3.y:2434 { - yyVAL.statement = &FetchCursor{Name: string(yyDollar[3].bytes), Variables: yyDollar[5].strs} + yyVAL.val = &FetchCursor{Name: string(yyDollar[3].bytes), Variables: yyDollar[5].val.([]string)} } case 437: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2577 - { - } - case 439: - yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2580 +//line sql3.y:2439 { } case 440: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2584 +//line sql3.y:2445 { - yyVAL.strs = []string{string(yyDollar[1].bytes)} + yyVAL.val = []string{string(yyDollar[1].bytes)} } case 441: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2588 +//line sql3.y:2449 { - yyVAL.strs = append(yyVAL.strs, string(yyDollar[3].bytes)) + yyVAL.val = append(yyVAL.val.([]string), string(yyDollar[3].bytes)) } case 442: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2594 +//line sql3.y:2455 { - yyVAL.statement = &Loop{Label: "", Statements: yyDollar[2].statements} + yyVAL.val = &Loop{Label: "", Statements: yyDollar[2].val.(Statements)} } case 443: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2598 +//line sql3.y:2459 { - yyVAL.statement = &Loop{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].statements} + yyVAL.val = &Loop{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].val.(Statements)} } case 444: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:2602 +//line sql3.y:2463 { label := string(yyDollar[1].bytes) if label != string(yyDollar[8].bytes) { yylex.Error("End-label " + string(yyDollar[8].bytes) + " without match") return 1 } - yyVAL.statement = &Loop{Label: label, Statements: yyDollar[4].statements} + yyVAL.val = &Loop{Label: label, Statements: yyDollar[4].val.(Statements)} } case 445: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2613 +//line sql3.y:2474 { - yyVAL.statement = &Repeat{Label: "", Statements: yyDollar[2].statements, Condition: yyDollar[5].expr} + yyVAL.val = &Repeat{Label: "", Statements: yyDollar[2].val.(Statements), Condition: yyDollar[5].val.(Expr)} } case 446: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:2617 +//line sql3.y:2478 { - yyVAL.statement = &Repeat{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].statements, Condition: yyDollar[7].expr} + yyVAL.val = &Repeat{Label: string(yyDollar[1].bytes), Statements: yyDollar[4].val.(Statements), Condition: yyDollar[7].val.(Expr)} } case 447: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:2621 +//line sql3.y:2482 { label := string(yyDollar[1].bytes) if label != string(yyDollar[10].bytes) { yylex.Error("End-label " + string(yyDollar[10].bytes) + " without match") return 1 } - yyVAL.statement = &Repeat{Label: label, Statements: yyDollar[4].statements, Condition: yyDollar[7].expr} + yyVAL.val = &Repeat{Label: label, Statements: yyDollar[4].val.(Statements), Condition: yyDollar[7].val.(Expr)} } case 448: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:2632 +//line sql3.y:2493 { - yyVAL.statement = &While{Label: "", Condition: yyDollar[2].expr, Statements: yyDollar[4].statements} + yyVAL.val = &While{Label: "", Condition: yyDollar[2].val.(Expr), Statements: yyDollar[4].val.(Statements)} } case 449: yyDollar = yyS[yypt-9 : yypt+1] -//line sql.y:2636 +//line sql3.y:2497 { - yyVAL.statement = &While{Label: string(yyDollar[1].bytes), Condition: yyDollar[4].expr, Statements: yyDollar[6].statements} + yyVAL.val = &While{Label: string(yyDollar[1].bytes), Condition: yyDollar[4].val.(Expr), Statements: yyDollar[6].val.(Statements)} } case 450: yyDollar = yyS[yypt-10 : yypt+1] -//line sql.y:2640 +//line sql3.y:2501 { label := string(yyDollar[1].bytes) if label != string(yyDollar[10].bytes) { yylex.Error("End-label " + string(yyDollar[10].bytes) + " without match") return 1 } - yyVAL.statement = &While{Label: label, Condition: yyDollar[4].expr, Statements: yyDollar[6].statements} + yyVAL.val = &While{Label: label, Condition: yyDollar[4].val.(Expr), Statements: yyDollar[6].val.(Statements)} } case 451: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2651 +//line sql3.y:2512 { - yyVAL.statement = &Leave{Label: string(yyDollar[2].bytes)} + yyVAL.val = &Leave{Label: string(yyDollar[2].bytes)} } case 452: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2657 +//line sql3.y:2518 { - yyVAL.statement = &Iterate{Label: string(yyDollar[2].bytes)} + yyVAL.val = &Iterate{Label: string(yyDollar[2].bytes)} } case 453: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2663 +//line sql3.y:2524 { - yyVAL.statement = &Return{Expr: yyDollar[2].expr} + yyVAL.val = &Return{Expr: yyDollar[2].val.(Expr)} } case 454: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2669 +//line sql3.y:2530 { - yyVAL.statement = &Signal{SqlStateValue: string(yyDollar[2].bytes)} + yyVAL.val = &Signal{SqlStateValue: string(yyDollar[2].bytes)} } case 455: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2673 +//line sql3.y:2534 { - yyVAL.statement = &Signal{SqlStateValue: string(yyDollar[2].bytes), Info: yyDollar[4].signalInfos} + yyVAL.val = &Signal{SqlStateValue: string(yyDollar[2].bytes), Info: yyDollar[4].val.([]SignalInfo)} } case 456: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2677 +//line sql3.y:2538 { - yyVAL.statement = &Signal{ConditionName: string(yyDollar[2].bytes)} + yyVAL.val = &Signal{ConditionName: string(yyDollar[2].bytes)} } case 457: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2681 +//line sql3.y:2542 { - yyVAL.statement = &Signal{ConditionName: string(yyDollar[2].bytes), Info: yyDollar[4].signalInfos} + yyVAL.val = &Signal{ConditionName: string(yyDollar[2].bytes), Info: yyDollar[4].val.([]SignalInfo)} } case 458: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2687 +//line sql3.y:2548 { yyVAL.bytes = yyDollar[2].bytes } case 459: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2691 +//line sql3.y:2552 { yyVAL.bytes = yyDollar[3].bytes } case 460: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2697 +//line sql3.y:2558 { - yyVAL.signalInfos = []SignalInfo{yyDollar[1].signalInfo} + yyVAL.val = []SignalInfo{yyDollar[1].val.(SignalInfo)} } case 461: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2701 +//line sql3.y:2562 { - yyVAL.signalInfos = append(yyVAL.signalInfos, yyDollar[3].signalInfo) + yyVAL.val = append(yyVAL.val.([]SignalInfo), yyDollar[3].val.(SignalInfo)) } case 462: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2707 +//line sql3.y:2568 { - yyVAL.signalInfo = SignalInfo{ConditionItemName: yyDollar[1].signalConditionItemName, Value: yyDollar[3].expr.(*SQLVal)} + yyVAL.val = SignalInfo{ConditionItemName: yyDollar[1].val.(SignalConditionItemName), Value: yyDollar[3].val.(Expr).(*SQLVal)} } case 463: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2711 +//line sql3.y:2572 { - yyVAL.signalInfo = SignalInfo{ConditionItemName: yyDollar[1].signalConditionItemName, Value: &ColName{Name: yyDollar[3].colIdent}} + yyVAL.val = SignalInfo{ConditionItemName: yyDollar[1].val.(SignalConditionItemName), Value: &ColName{Name: yyDollar[3].val.(ColIdent)}} } case 464: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2717 +//line sql3.y:2578 { - yyVAL.signalConditionItemName = SignalConditionItemName_ClassOrigin + yyVAL.val = SignalConditionItemName_ClassOrigin } case 465: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2721 +//line sql3.y:2582 { - yyVAL.signalConditionItemName = SignalConditionItemName_SubclassOrigin + yyVAL.val = SignalConditionItemName_SubclassOrigin } case 466: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2725 +//line sql3.y:2586 { - yyVAL.signalConditionItemName = SignalConditionItemName_MessageText + yyVAL.val = SignalConditionItemName_MessageText } case 467: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2729 +//line sql3.y:2590 { - yyVAL.signalConditionItemName = SignalConditionItemName_MysqlErrno + yyVAL.val = SignalConditionItemName_MysqlErrno } case 468: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2733 +//line sql3.y:2594 { - yyVAL.signalConditionItemName = SignalConditionItemName_ConstraintCatalog + yyVAL.val = SignalConditionItemName_ConstraintCatalog } case 469: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2737 +//line sql3.y:2598 { - yyVAL.signalConditionItemName = SignalConditionItemName_ConstraintSchema + yyVAL.val = SignalConditionItemName_ConstraintSchema } case 470: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2741 +//line sql3.y:2602 { - yyVAL.signalConditionItemName = SignalConditionItemName_ConstraintName + yyVAL.val = SignalConditionItemName_ConstraintName } case 471: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2745 +//line sql3.y:2606 { - yyVAL.signalConditionItemName = SignalConditionItemName_CatalogName + yyVAL.val = SignalConditionItemName_CatalogName } case 472: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2749 +//line sql3.y:2610 { - yyVAL.signalConditionItemName = SignalConditionItemName_SchemaName + yyVAL.val = SignalConditionItemName_SchemaName } case 473: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2753 +//line sql3.y:2614 { - yyVAL.signalConditionItemName = SignalConditionItemName_TableName + yyVAL.val = SignalConditionItemName_TableName } case 474: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2757 +//line sql3.y:2618 { - yyVAL.signalConditionItemName = SignalConditionItemName_ColumnName + yyVAL.val = SignalConditionItemName_ColumnName } case 475: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2761 +//line sql3.y:2622 { - yyVAL.signalConditionItemName = SignalConditionItemName_CursorName + yyVAL.val = SignalConditionItemName_CursorName } case 476: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2767 +//line sql3.y:2628 { - yyVAL.statement = &Resignal{} + yyVAL.val = &Resignal{} } case 477: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2771 +//line sql3.y:2632 { - yyVAL.statement = &Resignal{Signal{SqlStateValue: string(yyDollar[2].bytes)}} + yyVAL.val = &Resignal{Signal{SqlStateValue: string(yyDollar[2].bytes)}} } case 478: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2775 +//line sql3.y:2636 { - yyVAL.statement = &Resignal{Signal{SqlStateValue: string(yyDollar[2].bytes), Info: yyDollar[4].signalInfos}} + yyVAL.val = &Resignal{Signal{SqlStateValue: string(yyDollar[2].bytes), Info: yyDollar[4].val.([]SignalInfo)}} } case 479: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2779 +//line sql3.y:2640 { - yyVAL.statement = &Resignal{Signal{Info: yyDollar[3].signalInfos}} + yyVAL.val = &Resignal{Signal{Info: yyDollar[3].val.([]SignalInfo)}} } case 480: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2783 +//line sql3.y:2644 { - yyVAL.statement = &Resignal{Signal{ConditionName: string(yyDollar[2].bytes)}} + yyVAL.val = &Resignal{Signal{ConditionName: string(yyDollar[2].bytes)}} } case 481: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2787 +//line sql3.y:2648 { - yyVAL.statement = &Resignal{Signal{ConditionName: string(yyDollar[2].bytes), Info: yyDollar[4].signalInfos}} + yyVAL.val = &Resignal{Signal{ConditionName: string(yyDollar[2].bytes), Info: yyDollar[4].val.([]SignalInfo)}} } case 482: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:2793 +//line sql3.y:2654 { - yyVAL.statement = &Call{ProcName: yyDollar[2].procedureName, Params: yyDollar[3].exprs, AsOf: yyDollar[4].expr} + yyVAL.val = &Call{ProcName: yyDollar[2].val.(ProcedureName), Params: yyDollar[3].val.(Exprs), AsOf: yyDollar[4].val.(Expr)} } case 483: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:2798 +//line sql3.y:2659 { - yyVAL.exprs = nil + yyVAL.val = Exprs(nil) } case 484: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:2802 +//line sql3.y:2663 { - yyVAL.exprs = nil + yyVAL.val = Exprs(nil) } case 485: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2806 +//line sql3.y:2667 { - yyVAL.exprs = yyDollar[2].exprs + yyVAL.val = yyDollar[2].val.(Exprs) } case 486: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2812 +//line sql3.y:2673 { - yyVAL.statements = Statements{yyDollar[1].statement} + yyVAL.val = Statements{yyDollar[1].val.(Statement)} } case 487: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2816 +//line sql3.y:2677 { - yyVAL.statements = append(yyVAL.statements, yyDollar[3].statement) + yyVAL.val = append(yyVAL.val.(Statements), yyDollar[3].val.(Statement)) } case 488: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2822 +//line sql3.y:2683 { - yyVAL.statement = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 531: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2870 +//line sql3.y:2731 { var ne bool - if yyDollar[4].byt != 0 { + if yyDollar[4].val.(byte) != 0 { ne = true } var neTemp bool - if yyDollar[2].byt != 0 { + if yyDollar[2].val.(byte) != 0 { neTemp = true } - yyVAL.ddl = &DDL{Action: CreateStr, Table: yyDollar[5].tableName, IfNotExists: ne, Temporary: neTemp} + yyVAL.val = &DDL{Action: CreateStr, Table: yyDollar[5].val.(TableName), IfNotExists: ne, Temporary: neTemp} } case 532: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2884 +//line sql3.y:2745 { var ne bool - if yyDollar[4].byt != 0 { + if yyDollar[4].val.(byte) != 0 { ne = true } var neTemp bool - if yyDollar[2].byt != 0 { + if yyDollar[2].val.(byte) != 0 { neTemp = true } - yyVAL.ddl = &DDL{Action: CreateStr, Table: TableName{Name: NewTableIdent(string(yyDollar[5].bytes))}, IfNotExists: ne, Temporary: neTemp} + yyVAL.val = &DDL{Action: CreateStr, Table: TableName{Name: NewTableIdent(string(yyDollar[5].bytes))}, IfNotExists: ne, Temporary: neTemp} } case 533: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:2900 +//line sql3.y:2761 { - yyVAL.TableSpec = yyDollar[2].TableSpec - for _, opt := range yyDollar[4].tableOptions { - yyVAL.TableSpec.AddTableOption(opt) + yyVAL.val = yyDollar[2].val.(*TableSpec) + for _, opt := range yyDollar[4].val.([]*TableOption) { + yyVAL.val.(*TableSpec).AddTableOption(opt) } - yyVAL.TableSpec.PartitionOpt = yyDollar[5].partOption + yyVAL.val.(*TableSpec).PartitionOpt = yyDollar[5].val.(*PartitionOption) } case 534: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2910 +//line sql3.y:2771 { - yyVAL.TableSpec = &TableSpec{} - yyVAL.TableSpec.AddColumn(yyDollar[1].columnDefinition) + yyVAL.val = &TableSpec{} + yyVAL.val.(*TableSpec).AddColumn(yyDollar[1].val.(*ColumnDefinition)) } case 535: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:2915 +//line sql3.y:2776 { - yyVAL.TableSpec = &TableSpec{} - yyVAL.TableSpec.AddConstraint(yyDollar[1].constraintDefinition) + yyVAL.val = &TableSpec{} + yyVAL.val.(*TableSpec).AddConstraint(yyDollar[1].val.(*ConstraintDefinition)) } case 536: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2920 +//line sql3.y:2781 { - yyVAL.TableSpec.AddColumn(yyDollar[3].columnDefinition) + yyVAL.val.(*TableSpec).AddColumn(yyDollar[3].val.(*ColumnDefinition)) } case 537: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2924 +//line sql3.y:2785 { - yyVAL.TableSpec.AddIndex(yyDollar[3].indexDefinition) + yyVAL.val.(*TableSpec).AddIndex(yyDollar[3].val.(*IndexDefinition)) } case 538: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2928 +//line sql3.y:2789 { - yyVAL.TableSpec.AddConstraint(yyDollar[3].constraintDefinition) + yyVAL.val.(*TableSpec).AddConstraint(yyDollar[3].val.(*ConstraintDefinition)) } case 539: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2932 +//line sql3.y:2793 { - yyVAL.TableSpec.AddConstraint(yyDollar[3].constraintDefinition) + yyVAL.val.(*TableSpec).AddConstraint(yyDollar[3].val.(*ConstraintDefinition)) } case 540: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2938 +//line sql3.y:2799 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 541: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2946 +//line sql3.y:2808 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 542: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2956 +//line sql3.y:2819 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: yyDollar[1].colIdent, Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: yyDollar[1].val.(ColIdent), Type: yyDollar[2].val.(ColumnType)} } case 543: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2964 +//line sql3.y:2828 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 544: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2972 +//line sql3.y:2837 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 545: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2980 +//line sql3.y:2846 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 546: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2988 +//line sql3.y:2855 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 547: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:2996 +//line sql3.y:2864 { - if err := yyDollar[2].columnType.merge(yyDollar[3].columnType); err != nil { + ct := yyDollar[2].val.(ColumnType) + if err := ct.merge(yyDollar[3].val.(ColumnType)); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnDefinition = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].columnType} + yyVAL.val = &ColumnDefinition{Name: NewColIdent(string(yyDollar[1].bytes)), Type: yyDollar[2].val.(ColumnType)} } case 548: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3005 +//line sql3.y:2874 { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = BoolVal(false) } case 549: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3009 +//line sql3.y:2878 { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = BoolVal(false) } case 550: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3013 +//line sql3.y:2882 { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = BoolVal(true) } case 551: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3018 +//line sql3.y:2887 { - yyVAL.columnType = ColumnType{} + yyVAL.val = ColumnType{} } case 552: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3022 +//line sql3.y:2891 { - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 553: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3026 +//line sql3.y:2895 { opt := ColumnType{Null: BoolVal(true), NotNull: BoolVal(false), sawnull: true} - if err := yyDollar[1].columnType.merge(opt); err != nil { + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 554: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3035 +//line sql3.y:2905 { opt := ColumnType{Null: BoolVal(false), NotNull: BoolVal(true), sawnull: true} - if err := yyDollar[1].columnType.merge(opt); err != nil { + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 555: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3044 +//line sql3.y:2915 { - opt := ColumnType{Charset: yyDollar[2].str} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Charset: yyDollar[2].val.(string)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 556: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3053 +//line sql3.y:2925 { - opt := ColumnType{Collate: yyDollar[2].str} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Collate: yyDollar[2].val.(string)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 557: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3062 +//line sql3.y:2935 { opt := ColumnType{BinaryCollate: true} - if err := yyDollar[1].columnType.merge(opt); err != nil { + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 558: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3071 +//line sql3.y:2945 { - opt := ColumnType{Default: yyDollar[2].optVal} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Default: yyDollar[2].val.(Expr)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 559: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3080 +//line sql3.y:2955 { - opt := ColumnType{OnUpdate: yyDollar[2].optVal} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{OnUpdate: yyDollar[2].val.(Expr)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 560: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3089 +//line sql3.y:2965 { - opt := ColumnType{Autoincrement: yyDollar[2].boolVal, sawai: true} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Autoincrement: yyDollar[2].val.(BoolVal), sawai: true} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 561: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3098 +//line sql3.y:2975 { - opt := ColumnType{KeyOpt: yyDollar[2].colKeyOpt} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{KeyOpt: yyDollar[2].val.(ColumnKeyOption)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 562: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3107 +//line sql3.y:2985 { - opt := ColumnType{Comment: yyDollar[2].sqlVal} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Comment: yyDollar[2].val.(*SQLVal)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 563: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:3116 +//line sql3.y:2995 { - opt := ColumnType{GeneratedExpr: &ParenExpr{yyDollar[4].expr}, Stored: yyDollar[6].boolVal} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{GeneratedExpr: &ParenExpr{yyDollar[4].val.(Expr)}, Stored: yyDollar[6].val.(BoolVal)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 564: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:3125 +//line sql3.y:3005 { - opt := ColumnType{GeneratedExpr: &ParenExpr{yyDollar[6].expr}, Stored: yyDollar[8].boolVal} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{GeneratedExpr: &ParenExpr{yyDollar[6].val.(Expr)}, Stored: yyDollar[8].val.(BoolVal)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 565: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3134 +//line sql3.y:3015 { opt := ColumnType{SRID: NewIntVal(yyDollar[3].bytes)} - if err := yyDollar[1].columnType.merge(opt); err != nil { + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 566: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:3144 +//line sql3.y:3026 { - opt := ColumnType{ForeignKeyDef: &ForeignKeyDefinition{ReferencedTable: yyDollar[3].tableName, ReferencedColumns: yyDollar[5].columns}} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{ForeignKeyDef: &ForeignKeyDefinition{ReferencedTable: yyDollar[3].val.(TableName), ReferencedColumns: yyDollar[5].val.(Columns)}} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 567: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3153 +//line sql3.y:3036 { - opt := ColumnType{Constraint: yyDollar[2].constraintDefinition} - if err := yyDollar[1].columnType.merge(opt); err != nil { + opt := ColumnType{Constraint: yyDollar[2].val.(*ConstraintDefinition)} + ct := yyDollar[1].val.(ColumnType) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 568: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3164 +//line sql3.y:3048 { - yyVAL.columnType = yyDollar[1].columnType - yyVAL.columnType.Unsigned = yyDollar[2].boolVal - yyVAL.columnType.Zerofill = yyDollar[3].boolVal + ct := yyDollar[1].val.(ColumnType) + ct.Unsigned = yyDollar[2].val.(BoolVal) + ct.Zerofill = yyDollar[3].val.(BoolVal) + yyVAL.val = ct } case 572: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3175 +//line sql3.y:3060 { - yyVAL.columnType = yyDollar[1].columnType - yyVAL.columnType.Length = yyDollar[2].sqlVal + ct := yyDollar[1].val.(ColumnType) + ct.Length = yyDollar[2].val.(*SQLVal) + yyVAL.val = ct } case 573: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3180 +//line sql3.y:3066 { - yyVAL.columnType = yyDollar[1].columnType + yyVAL.val = yyDollar[1].val.(ColumnType) } case 574: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3186 +//line sql3.y:3072 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 575: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3190 +//line sql3.y:3076 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 576: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3194 +//line sql3.y:3080 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 577: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3198 +//line sql3.y:3084 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 578: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3202 +//line sql3.y:3088 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 579: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3206 +//line sql3.y:3092 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 580: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3210 +//line sql3.y:3096 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 581: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3214 +//line sql3.y:3100 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 582: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3218 +//line sql3.y:3104 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 583: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3222 +//line sql3.y:3108 { - yyVAL.columnType = ColumnType{Type: "bigint", Unsigned: true, NotNull: true, Autoincrement: true, KeyOpt: colKeyUnique} + yyVAL.val = ColumnType{Type: "bigint", Unsigned: true, NotNull: true, Autoincrement: true, KeyOpt: colKeyUnique} } case 584: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3226 +//line sql3.y:3112 { - yyVAL.columnType = ColumnType{Type: "tinyint"} + yyVAL.val = ColumnType{Type: "tinyint"} } case 585: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3230 +//line sql3.y:3116 { - yyVAL.columnType = ColumnType{Type: "smallint"} + yyVAL.val = ColumnType{Type: "smallint"} } case 586: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3234 +//line sql3.y:3120 { - yyVAL.columnType = ColumnType{Type: "mediumint"} + yyVAL.val = ColumnType{Type: "mediumint"} } case 587: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3238 +//line sql3.y:3124 { - yyVAL.columnType = ColumnType{Type: "int"} + yyVAL.val = ColumnType{Type: "int"} } case 588: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3242 +//line sql3.y:3128 { - yyVAL.columnType = ColumnType{Type: "bigint"} + yyVAL.val = ColumnType{Type: "bigint"} } case 589: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3248 +//line sql3.y:3134 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 590: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3254 +//line sql3.y:3141 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 591: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3260 +//line sql3.y:3148 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} - yyVAL.columnType.Length = yyDollar[3].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[3].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + ct.Length = yyDollar[3].val.(LengthScaleOption).Length + ct.Scale = yyDollar[3].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 592: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3266 +//line sql3.y:3155 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 593: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3272 +//line sql3.y:3162 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 594: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3278 +//line sql3.y:3169 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 595: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3284 +//line sql3.y:3176 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 596: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3290 +//line sql3.y:3183 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} - yyVAL.columnType.Length = yyDollar[2].LengthScaleOption.Length - yyVAL.columnType.Scale = yyDollar[2].LengthScaleOption.Scale + ct := ColumnType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct } case 597: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3298 +//line sql3.y:3192 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 598: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3302 +//line sql3.y:3196 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 599: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3306 +//line sql3.y:3200 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 600: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3310 +//line sql3.y:3204 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 601: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3314 +//line sql3.y:3208 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 602: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3320 +//line sql3.y:3214 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 603: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3324 +//line sql3.y:3218 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 604: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3328 +//line sql3.y:3222 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 605: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3332 +//line sql3.y:3226 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 606: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3336 +//line sql3.y:3230 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 607: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3340 +//line sql3.y:3234 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 608: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3344 +//line sql3.y:3238 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 609: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3348 +//line sql3.y:3242 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 610: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3352 +//line sql3.y:3246 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 611: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3356 +//line sql3.y:3250 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Length: yyDollar[3].val.(*SQLVal)} } case 612: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3360 +//line sql3.y:3254 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Length: yyDollar[4].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Length: yyDollar[4].val.(*SQLVal)} } case 613: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3364 +//line sql3.y:3258 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 614: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3368 +//line sql3.y:3262 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 615: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3372 +//line sql3.y:3266 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 616: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3376 +//line sql3.y:3270 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 617: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3380 +//line sql3.y:3274 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 618: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3384 +//line sql3.y:3278 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 619: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3388 +//line sql3.y:3282 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 620: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3392 +//line sql3.y:3286 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 621: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3396 +//line sql3.y:3290 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 622: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3400 +//line sql3.y:3294 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 623: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3404 +//line sql3.y:3298 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 624: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3408 +//line sql3.y:3302 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 625: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3412 +//line sql3.y:3306 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 626: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3416 +//line sql3.y:3310 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].strs} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].val.([]string)} } case 627: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3421 +//line sql3.y:3315 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].strs} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].val.([]string)} } case 628: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3427 +//line sql3.y:3321 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 629: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3431 +//line sql3.y:3325 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 630: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3435 +//line sql3.y:3329 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 631: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3439 +//line sql3.y:3333 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 632: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3443 +//line sql3.y:3337 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 633: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3447 +//line sql3.y:3341 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 634: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3451 +//line sql3.y:3345 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 635: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3455 +//line sql3.y:3349 { - yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} + yyVAL.val = ColumnType{Type: string(yyDollar[1].bytes)} } case 636: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3461 +//line sql3.y:3355 { - yyVAL.strs = make([]string, 0, 4) - yyVAL.strs = append(yyVAL.strs, string(yyDollar[1].bytes)) + yyVAL.val = make([]string, 0, 4) + yyVAL.val = append(yyVAL.val.([]string), string(yyDollar[1].bytes)) } case 637: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3466 +//line sql3.y:3360 { - yyVAL.strs = append(yyDollar[1].strs, string(yyDollar[3].bytes)) + yyVAL.val = append(yyDollar[1].val.([]string), string(yyDollar[3].bytes)) } case 638: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3471 +//line sql3.y:3365 { - yyVAL.sqlVal = nil + yyVAL.val = &SQLVal{} } case 639: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3475 +//line sql3.y:3369 { - yyVAL.sqlVal = NewIntVal(yyDollar[2].bytes) + yyVAL.val = NewIntVal(yyDollar[2].bytes) } case 640: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3480 +//line sql3.y:3374 { - yyVAL.sqlVal = nil + yyVAL.val = &SQLVal{} } case 641: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3484 +//line sql3.y:3378 { - yyVAL.sqlVal = NewIntVal(yyDollar[2].bytes) + yyVAL.val = NewIntVal(yyDollar[2].bytes) } case 642: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3488 +//line sql3.y:3382 { - yyVAL.sqlVal = NewValArg(yyDollar[2].bytes) + yyVAL.val = NewValArg(yyDollar[2].bytes) } case 643: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3493 +//line sql3.y:3387 { - yyVAL.LengthScaleOption = LengthScaleOption{} + yyVAL.val = LengthScaleOption{} } case 644: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3497 +//line sql3.y:3391 { - yyVAL.LengthScaleOption = LengthScaleOption{ + yyVAL.val = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), Scale: NewIntVal(yyDollar[4].bytes), } } case 645: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3505 +//line sql3.y:3399 { - yyVAL.LengthScaleOption = LengthScaleOption{} + yyVAL.val = LengthScaleOption{} } case 646: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3509 +//line sql3.y:3403 { - yyVAL.LengthScaleOption = LengthScaleOption{ + yyVAL.val = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), } } case 647: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3515 +//line sql3.y:3409 { - yyVAL.LengthScaleOption = LengthScaleOption{ + yyVAL.val = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), Scale: NewIntVal(yyDollar[4].bytes), } } case 648: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3523 +//line sql3.y:3417 { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = BoolVal(false) } case 649: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3527 +//line sql3.y:3421 { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = BoolVal(false) } case 650: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3531 +//line sql3.y:3425 { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = BoolVal(true) } case 651: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3536 +//line sql3.y:3430 { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = BoolVal(false) } case 652: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3540 +//line sql3.y:3434 { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = BoolVal(true) } case 653: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3546 +//line sql3.y:3440 { - yyVAL.optVal = yyDollar[2].expr + yyVAL.val = yyDollar[2].val.(Expr) } case 654: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3550 +//line sql3.y:3444 { - if num, ok := yyDollar[3].expr.(*SQLVal); ok && num.Type == IntVal { + if num, ok := yyDollar[3].val.(Expr).(*SQLVal); ok && num.Type == IntVal { // Handle double negative if num.Val[0] == '-' { num.Val = num.Val[1:] - yyVAL.optVal = num + yyVAL.val = num } else { - yyVAL.optVal = NewIntVal(append([]byte("-"), num.Val...)) + yyVAL.val = NewIntVal(append([]byte("-"), num.Val...)) } } else { - yyVAL.optVal = &UnaryExpr{Operator: UMinusStr, Expr: yyDollar[3].expr} + yyVAL.val = &UnaryExpr{Operator: UMinusStr, Expr: yyDollar[3].val.(Expr)} } } case 655: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3564 +//line sql3.y:3458 { - yyVAL.optVal = &UnaryExpr{Operator: yyDollar[2].str, Expr: NewStrVal(yyDollar[3].bytes)} + yyVAL.val = &UnaryExpr{Operator: yyDollar[2].val.(string), Expr: NewStrVal(yyDollar[3].bytes)} } case 656: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3568 +//line sql3.y:3462 { - yyVAL.optVal = yyDollar[2].boolVal + yyVAL.val = yyDollar[2].val.(BoolVal) } case 657: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3572 +//line sql3.y:3466 { - yyVAL.optVal = yyDollar[2].expr + yyVAL.val = yyDollar[2].val.(Expr) } case 658: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3576 +//line sql3.y:3470 { - yyVAL.optVal = &ParenExpr{yyDollar[3].expr} + yyVAL.val = &ParenExpr{yyDollar[3].val.(Expr)} } case 659: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3582 +//line sql3.y:3476 { - yyVAL.optVal = yyDollar[3].expr + yyVAL.val = yyDollar[3].val.(Expr) } case 660: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3588 +//line sql3.y:3482 { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = BoolVal(true) } case 661: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3593 +//line sql3.y:3487 { - yyVAL.str = "" + yyVAL.val = "" } case 662: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3597 +//line sql3.y:3491 { - yyVAL.str = yyDollar[1].str + yyVAL.val = yyDollar[1].val.(string) } case 663: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3603 +//line sql3.y:3497 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 664: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3607 +//line sql3.y:3501 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 665: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3611 +//line sql3.y:3505 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 666: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3615 +//line sql3.y:3509 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 667: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3621 +//line sql3.y:3515 { - yyVAL.str = "" + yyVAL.val = "" } case 668: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3625 +//line sql3.y:3519 { - yyVAL.str = yyDollar[1].str + yyVAL.val = yyDollar[1].val.(string) } case 669: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3631 +//line sql3.y:3525 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 670: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3635 +//line sql3.y:3529 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 671: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3639 +//line sql3.y:3533 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 672: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3644 +//line sql3.y:3538 { - yyVAL.boolean = false + yyVAL.val = false } case 673: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3648 +//line sql3.y:3542 { - yyVAL.boolean = true + yyVAL.val = true } case 674: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3653 +//line sql3.y:3547 { - yyVAL.charsetCollates = nil + yyVAL.val = []*CharsetAndCollate(nil) } case 675: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3657 +//line sql3.y:3551 { - yyVAL.charsetCollates = yyDollar[1].charsetCollates + yyVAL.val = yyDollar[1].val.([]*CharsetAndCollate) } case 676: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3663 +//line sql3.y:3557 { - yyVAL.charsetCollates = []*CharsetAndCollate{yyDollar[1].charsetCollate} + yyVAL.val = []*CharsetAndCollate{yyDollar[1].val.(*CharsetAndCollate)} } case 677: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3667 +//line sql3.y:3561 { - yyVAL.charsetCollates = []*CharsetAndCollate{yyDollar[1].charsetCollate} + yyVAL.val = []*CharsetAndCollate{yyDollar[1].val.(*CharsetAndCollate)} } case 678: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3671 +//line sql3.y:3565 { - yyVAL.charsetCollates = []*CharsetAndCollate{yyDollar[1].charsetCollate} + yyVAL.val = []*CharsetAndCollate{yyDollar[1].val.(*CharsetAndCollate)} } case 679: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3675 +//line sql3.y:3569 { - yyVAL.charsetCollates = append(yyDollar[1].charsetCollates, yyDollar[2].charsetCollate) + yyVAL.val = append(yyDollar[1].val.([]*CharsetAndCollate), yyDollar[2].val.(*CharsetAndCollate)) } case 680: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3679 +//line sql3.y:3573 { - yyVAL.charsetCollates = append(yyDollar[1].charsetCollates, yyDollar[2].charsetCollate) + yyVAL.val = append(yyDollar[1].val.([]*CharsetAndCollate), yyDollar[2].val.(*CharsetAndCollate)) } case 681: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3683 +//line sql3.y:3577 { - yyVAL.charsetCollates = append(yyDollar[1].charsetCollates, yyDollar[2].charsetCollate) + yyVAL.val = append(yyDollar[1].val.([]*CharsetAndCollate), yyDollar[2].val.(*CharsetAndCollate)) } case 682: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3689 +//line sql3.y:3583 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].val.(bool)} } case 683: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3693 +//line sql3.y:3587 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].val.(bool)} } case 684: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3697 +//line sql3.y:3591 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: string(yyDollar[5].bytes), IsDefault: yyDollar[1].val.(bool)} } case 685: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3701 +//line sql3.y:3595 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 686: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3705 +//line sql3.y:3599 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 687: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3709 +//line sql3.y:3603 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 688: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3715 +//line sql3.y:3609 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 689: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3719 +//line sql3.y:3613 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 690: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3723 +//line sql3.y:3617 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 691: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3729 +//line sql3.y:3623 { - yyVAL.charsetCollate = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].boolean} + yyVAL.val = &CharsetAndCollate{Type: string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes), IsDefault: yyDollar[1].val.(bool)} } case 692: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3735 +//line sql3.y:3629 { - yyVAL.colKeyOpt = colKeyPrimary + yyVAL.val = colKeyPrimary } case 693: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3739 +//line sql3.y:3633 { - yyVAL.colKeyOpt = colKey + yyVAL.val = colKey } case 694: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3743 +//line sql3.y:3637 { - yyVAL.colKeyOpt = colKeyUniqueKey + yyVAL.val = colKeyUniqueKey } case 695: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3747 +//line sql3.y:3641 { - yyVAL.colKeyOpt = colKeyUnique + yyVAL.val = colKeyUnique } case 696: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3751 +//line sql3.y:3645 { - yyVAL.colKeyOpt = colKeyFulltextKey + yyVAL.val = colKeyFulltextKey } case 697: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3757 +//line sql3.y:3651 { - yyVAL.sqlVal = NewStrVal(yyDollar[2].bytes) + yyVAL.val = NewStrVal(yyDollar[2].bytes) } case 698: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3763 +//line sql3.y:3657 { - yyVAL.statement = &PurgeBinaryLogs{To: string(yyDollar[5].bytes)} + yyVAL.val = &PurgeBinaryLogs{To: string(yyDollar[5].bytes)} } case 699: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3767 +//line sql3.y:3661 { - yyVAL.statement = &PurgeBinaryLogs{Before: yyDollar[5].expr} + yyVAL.val = &PurgeBinaryLogs{Before: yyDollar[5].val.(Expr)} } case 700: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3773 +//line sql3.y:3667 { - yyVAL.statement = &Flush{Type: yyDollar[2].str, Option: yyDollar[3].flushOption} + yyVAL.val = &Flush{Type: yyDollar[2].val.(string), Option: yyDollar[3].val.(*FlushOption)} } case 701: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3779 +//line sql3.y:3673 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 702: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3783 +//line sql3.y:3677 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 703: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3787 +//line sql3.y:3681 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 704: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3791 +//line sql3.y:3685 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 705: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3795 +//line sql3.y:3689 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 706: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3799 +//line sql3.y:3693 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 707: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3803 +//line sql3.y:3697 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 708: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3807 +//line sql3.y:3701 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 709: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3811 +//line sql3.y:3705 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Channel: yyDollar[3].str} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Channel: yyDollar[3].val.(string)} } case 710: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3815 +//line sql3.y:3709 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes)} } case 711: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3819 +//line sql3.y:3713 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 712: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3823 +//line sql3.y:3717 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes)} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes)} } case 713: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3827 +//line sql3.y:3721 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes), Tables: yyDollar[2].tableNames, ReadLock: yyDollar[3].boolean} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes), Tables: yyDollar[2].val.(TableNames), ReadLock: yyDollar[3].val.(bool)} } case 714: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3831 +//line sql3.y:3725 { - yyVAL.flushOption = &FlushOption{Name: string(yyDollar[1].bytes), Tables: yyDollar[2].tableNames, ReadLock: yyDollar[3].boolean} + yyVAL.val = &FlushOption{Name: string(yyDollar[1].bytes), Tables: yyDollar[2].val.(TableNames), ReadLock: yyDollar[3].val.(bool)} } case 715: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3836 +//line sql3.y:3730 { - yyVAL.boolean = false + yyVAL.val = false } case 716: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3838 +//line sql3.y:3734 { - yyVAL.boolean = true + yyVAL.val = true } case 717: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3841 +//line sql3.y:3739 { - yyVAL.str = "" + yyVAL.val = "" } case 718: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3843 +//line sql3.y:3743 { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 719: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3847 +//line sql3.y:3749 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 720: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3849 +//line sql3.y:3753 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 721: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3852 +//line sql3.y:3758 { - yyVAL.str = "" + yyVAL.val = "" } case 722: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3854 +//line sql3.y:3762 { - yyVAL.str = yyDollar[1].str + yyVAL.val = yyDollar[1].val.(string) } case 723: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3858 +//line sql3.y:3768 { - yyVAL.statement = &ChangeReplicationSource{Options: yyDollar[5].replicationOptions} + yyVAL.val = &ChangeReplicationSource{Options: yyDollar[5].val.([]*ReplicationOption)} } case 724: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3862 +//line sql3.y:3772 { - yyVAL.statement = &ChangeReplicationFilter{Options: yyDollar[4].replicationOptions} + yyVAL.val = &ChangeReplicationFilter{Options: yyDollar[4].val.([]*ReplicationOption)} } case 725: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3866 +//line sql3.y:3776 { - yyVAL.statement = &StartReplica{} + yyVAL.val = &StartReplica{} } case 726: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3870 +//line sql3.y:3780 { - yyVAL.statement = &StopReplica{} + yyVAL.val = &StopReplica{} } case 727: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3874 +//line sql3.y:3784 { - yyVAL.statement = &ResetReplica{All: yyDollar[3].boolean} + yyVAL.val = &ResetReplica{All: yyDollar[3].val.(bool)} } case 728: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3879 +//line sql3.y:3789 { - yyVAL.boolean = false + yyVAL.val = false } case 729: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3881 +//line sql3.y:3793 { - yyVAL.boolean = true + yyVAL.val = true } case 730: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3886 +//line sql3.y:3800 { - yyVAL.replicationOptions = []*ReplicationOption{yyDollar[1].replicationOption} + yyVAL.val = []*ReplicationOption{yyDollar[1].val.(*ReplicationOption)} } case 731: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3890 +//line sql3.y:3804 { - yyVAL.replicationOptions = append(yyVAL.replicationOptions, yyDollar[3].replicationOption) + yyVAL.val = append(yyVAL.val.([]*ReplicationOption), yyDollar[3].val.(*ReplicationOption)) } case 732: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3896 +//line sql3.y:3810 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 733: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3900 +//line sql3.y:3814 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 734: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3904 +//line sql3.y:3818 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 735: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3908 +//line sql3.y:3822 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} } case 736: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3912 +//line sql3.y:3826 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} } case 737: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3916 +//line sql3.y:3830 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} } case 738: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3920 +//line sql3.y:3834 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: mustAtoi(yylex, string(yyDollar[3].bytes))} } case 739: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3926 +//line sql3.y:3840 { - yyVAL.replicationOptions = []*ReplicationOption{yyDollar[1].replicationOption} + yyVAL.val = []*ReplicationOption{yyDollar[1].val.(*ReplicationOption)} } case 740: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3930 +//line sql3.y:3844 { - yyVAL.replicationOptions = append(yyVAL.replicationOptions, yyDollar[3].replicationOption) + yyVAL.val = append(yyVAL.val.([]*ReplicationOption), yyDollar[3].val.(*ReplicationOption)) } case 741: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3936 +//line sql3.y:3850 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: yyDollar[4].tableNames} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: yyDollar[4].val.(TableNames)} } case 742: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3940 +//line sql3.y:3854 { - yyVAL.replicationOption = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: yyDollar[4].tableNames} + yyVAL.val = &ReplicationOption{Name: string(yyDollar[1].bytes), Value: yyDollar[4].val.(TableNames)} } case 743: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:3946 +//line sql3.y:3860 { - yyVAL.indexDefinition = &IndexDefinition{Info: yyDollar[1].indexInfo, Columns: yyDollar[3].indexColumns, Options: yyDollar[5].indexOptions} + yyVAL.val = &IndexDefinition{Info: yyDollar[1].val.(*IndexInfo), Columns: yyDollar[3].val.([]*IndexColumn), Options: yyDollar[5].val.([]*IndexOption)} } case 744: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:3950 +//line sql3.y:3864 { - yyVAL.indexDefinition = &IndexDefinition{Info: yyDollar[1].indexInfo, Columns: yyDollar[3].indexColumns} + yyVAL.val = &IndexDefinition{Info: yyDollar[1].val.(*IndexInfo), Columns: yyDollar[3].val.([]*IndexColumn)} } case 745: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:3955 +//line sql3.y:3869 { - yyVAL.indexOptions = nil + yyVAL.val = []*IndexOption(nil) } case 746: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3959 +//line sql3.y:3873 { - yyVAL.indexOptions = yyDollar[1].indexOptions + yyVAL.val = yyDollar[1].val.([]*IndexOption) } case 747: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3965 +//line sql3.y:3879 { - yyVAL.indexOptions = []*IndexOption{yyDollar[1].indexOption} + yyVAL.val = []*IndexOption{yyDollar[1].val.(*IndexOption)} } case 748: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3969 +//line sql3.y:3883 { - yyVAL.indexOptions = append(yyVAL.indexOptions, yyDollar[2].indexOption) + yyVAL.val = append(yyVAL.val.([]*IndexOption), yyDollar[2].val.(*IndexOption)) } case 749: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3975 +//line sql3.y:3890 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Using: string(yyDollar[2].bytes)} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Using: string(yyDollar[2].bytes)} } case 750: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3979 +//line sql3.y:3894 { // should not be string - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewIntVal(yyDollar[3].bytes)} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewIntVal(yyDollar[3].bytes)} } case 751: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:3984 +//line sql3.y:3899 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[2].bytes)} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[2].bytes)} } case 752: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3988 +//line sql3.y:3903 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[3].bytes)} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[3].bytes)} } case 753: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:3992 +//line sql3.y:3907 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[3].bytes)} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: NewStrVal(yyDollar[3].bytes)} } case 754: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:3996 +//line sql3.y:3911 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: nil} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: nil} } case 755: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4000 +//line sql3.y:3915 { - yyVAL.indexOption = &IndexOption{Name: string(yyDollar[1].bytes), Value: nil} + yyVAL.val = &IndexOption{Name: string(yyDollar[1].bytes), Value: nil} } case 756: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:4006 +//line sql3.y:3921 { - yyVAL.str = "" + yyVAL.val = "" } case 757: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4010 +//line sql3.y:3925 { - yyVAL.str = string(yyDollar[1].str) + yyVAL.val = string(yyDollar[1].val.(string)) } case 758: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4016 +//line sql3.y:3931 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 759: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4020 +//line sql3.y:3935 { - yyVAL.str = ":=" + yyVAL.val = ":=" } case 760: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4028 +//line sql3.y:3943 { - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Name: NewColIdent("PRIMARY"), Primary: true, Unique: true} + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Name: NewColIdent("PRIMARY"), Primary: true, Unique: true} } case 761: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:4032 +//line sql3.y:3947 { - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes), Name: NewColIdent("PRIMARY"), Primary: true, Unique: true} + yyVAL.val = &IndexInfo{Type: string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes), Name: NewColIdent("PRIMARY"), Primary: true, Unique: true} } case 762: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4036 +//line sql3.y:3951 { - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].str), Name: NewColIdent(yyDollar[3].str), Spatial: true, Unique: false} + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].val.(string)), Name: NewColIdent(yyDollar[3].val.(string)), Spatial: true, Unique: false} } case 763: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4040 +//line sql3.y:3955 { - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].str), Name: NewColIdent(yyDollar[3].str), Fulltext: true} + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].val.(string)), Name: NewColIdent(yyDollar[3].val.(string)), Fulltext: true} } case 764: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4044 +======= +//line sql3.y:3959 +>>>>>>> Stashed changes { var name string - name = yyDollar[2].str + name = yyDollar[2].val.(string) if name == "" { - name = yyDollar[5].str + name = yyDollar[5].val.(string) } - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[3].bytes) + " " + string(yyDollar[4].str), Name: NewColIdent(name), Unique: true} + yyVAL.val = &IndexInfo{Type: string(yyDollar[3].bytes) + " " + string(yyDollar[4].val.(string)), Name: NewColIdent(name), Unique: true} + } + case 765: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:3968 + { + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].val.(string)), Name: NewColIdent(yyDollar[3].val.(string)), Unique: true} } +<<<<<<< Updated upstream case 765: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:4053 +======= + case 766: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:3972 +>>>>>>> Stashed changes { - yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[1].bytes) + " " + string(yyDollar[2].str), Name: NewColIdent(yyDollar[3].str), Unique: true} + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].bytes), Name: NewColIdent(yyDollar[2].val.(string)), Unique: true} } case 766: yyDollar = yyS[yypt-2 : yypt+1] @@ -16812,8 +17389,9 @@ yydefault: } case 767: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4061 +//line sql3.y:3976 { +<<<<<<< Updated upstream yyVAL.indexInfo = &IndexInfo{Type: string(yyDollar[1].str), Name: NewColIdent(yyDollar[2].str), Unique: false} } case 768: @@ -16821,48 +17399,83 @@ yydefault: //line sql.y:4067 { yyVAL.str = string(yyDollar[1].bytes) +======= + yyVAL.val = &IndexInfo{Type: string(yyDollar[1].val.(string)), Name: NewColIdent(yyDollar[2].val.(string)), Unique: false} + } + case 768: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:3982 + { + yyVAL.val = string(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 769: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4071 +//line sql3.y:3986 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 770: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4075 +//line sql3.y:3990 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 771: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4081 +======= +//line sql3.y:3996 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 772: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4085 +//line sql3.y:4000 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 773: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4090 +======= +//line sql3.y:4005 { - yyVAL.str = "" + yyVAL.val = "" + } + case 774: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4009 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(string) } +<<<<<<< Updated upstream case 774: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4094 +======= + case 775: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4014 +>>>>>>> Stashed changes { - yyVAL.str = yyDollar[1].str + yyVAL.val = "" } +<<<<<<< Updated upstream case 775: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4099 +======= + case 776: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4018 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = string(yyDollar[1].bytes) } case 776: yyDollar = yyS[yypt-1 : yypt+1] @@ -16872,21 +17485,35 @@ yydefault: } case 777: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4107 +//line sql3.y:4022 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 778: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4113 +======= +//line sql3.y:4028 + { + yyVAL.val = []*IndexColumn{yyDollar[1].val.(*IndexColumn)} + } + case 779: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4032 +>>>>>>> Stashed changes { - yyVAL.indexColumns = []*IndexColumn{yyDollar[1].indexColumn} + yyVAL.val = append(yyVAL.val.([]*IndexColumn), yyDollar[3].val.(*IndexColumn)) } case 779: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4117 +======= +//line sql3.y:4038 +>>>>>>> Stashed changes { - yyVAL.indexColumns = append(yyVAL.indexColumns, yyDollar[3].indexColumn) + yyVAL.val = &IndexColumn{Column: NewColIdent(string(yyDollar[1].bytes)), Length: yyDollar[2].val.(*SQLVal), Order: yyDollar[3].val.(string)} } case 780: yyDollar = yyS[yypt-3 : yypt+1] @@ -16896,33 +17523,61 @@ yydefault: } case 781: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4127 +//line sql3.y:4042 { - yyVAL.indexColumn = &IndexColumn{Column: NewColIdent(string(yyDollar[1].bytes)), Length: yyDollar[2].sqlVal, Order: yyDollar[3].str} + yyVAL.val = &IndexColumn{Column: NewColIdent(string(yyDollar[1].bytes)), Length: yyDollar[2].val.(*SQLVal), Order: yyDollar[3].val.(string)} } case 782: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4133 +======= +//line sql3.y:4048 { - yyVAL.constraintDefinition = &ConstraintDefinition{Name: string(yyDollar[2].bytes), Details: yyDollar[3].constraintInfo} + yyVAL.val = &ConstraintDefinition{Name: string(yyDollar[2].bytes), Details: yyDollar[3].val.(ConstraintInfo)} } case 783: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4052 +>>>>>>> Stashed changes + { + yyVAL.val = &ConstraintDefinition{Details: yyDollar[2].val.(ConstraintInfo)} + } +<<<<<<< Updated upstream + case 783: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4137 +======= + case 784: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4056 +>>>>>>> Stashed changes { - yyVAL.constraintDefinition = &ConstraintDefinition{Details: yyDollar[2].constraintInfo} + yyVAL.val = &ConstraintDefinition{Details: yyDollar[1].val.(ConstraintInfo)} } +<<<<<<< Updated upstream case 784: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4141 +======= + case 785: + yyDollar = yyS[yypt-11 : yypt+1] +//line sql3.y:4062 +>>>>>>> Stashed changes { - yyVAL.constraintDefinition = &ConstraintDefinition{Details: yyDollar[1].constraintInfo} + yyVAL.val = &ForeignKeyDefinition{Source: yyDollar[5].val.(Columns), ReferencedTable: yyDollar[8].val.(TableName), ReferencedColumns: yyDollar[10].val.(Columns), Index: string(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 785: yyDollar = yyS[yypt-11 : yypt+1] //line sql.y:4147 +======= + case 786: + yyDollar = yyS[yypt-12 : yypt+1] +//line sql3.y:4066 +>>>>>>> Stashed changes { - yyVAL.constraintInfo = &ForeignKeyDefinition{Source: yyDollar[5].columns, ReferencedTable: yyDollar[8].tableName, ReferencedColumns: yyDollar[10].columns, Index: string(yyDollar[3].bytes)} + yyVAL.val = &ForeignKeyDefinition{Source: yyDollar[5].val.(Columns), ReferencedTable: yyDollar[8].val.(TableName), ReferencedColumns: yyDollar[10].val.(Columns), OnDelete: yyDollar[12].val.(ReferenceAction), Index: string(yyDollar[3].bytes)} } case 786: yyDollar = yyS[yypt-12 : yypt+1] @@ -16932,8 +17587,9 @@ yydefault: } case 787: yyDollar = yyS[yypt-12 : yypt+1] -//line sql.y:4155 +//line sql3.y:4070 { +<<<<<<< Updated upstream yyVAL.constraintInfo = &ForeignKeyDefinition{Source: yyDollar[5].columns, ReferencedTable: yyDollar[8].tableName, ReferencedColumns: yyDollar[10].columns, OnUpdate: yyDollar[12].ReferenceAction, Index: string(yyDollar[3].bytes)} } case 788: @@ -16941,11 +17597,21 @@ yydefault: //line sql.y:4159 { yyVAL.constraintInfo = &ForeignKeyDefinition{Source: yyDollar[5].columns, ReferencedTable: yyDollar[8].tableName, ReferencedColumns: yyDollar[10].columns, OnDelete: yyDollar[12].ReferenceAction, OnUpdate: yyDollar[13].ReferenceAction, Index: string(yyDollar[3].bytes)} +======= + yyVAL.val = &ForeignKeyDefinition{Source: yyDollar[5].val.(Columns), ReferencedTable: yyDollar[8].val.(TableName), ReferencedColumns: yyDollar[10].val.(Columns), OnUpdate: yyDollar[12].val.(ReferenceAction), Index: string(yyDollar[3].bytes)} + } + case 788: + yyDollar = yyS[yypt-13 : yypt+1] +//line sql3.y:4074 + { + yyVAL.val = &ForeignKeyDefinition{Source: yyDollar[5].val.(Columns), ReferencedTable: yyDollar[8].val.(TableName), ReferencedColumns: yyDollar[10].val.(Columns), OnDelete: yyDollar[12].val.(ReferenceAction), OnUpdate: yyDollar[13].val.(ReferenceAction), Index: string(yyDollar[3].bytes)} +>>>>>>> Stashed changes } case 789: yyDollar = yyS[yypt-13 : yypt+1] -//line sql.y:4163 +//line sql3.y:4078 { +<<<<<<< Updated upstream yyVAL.constraintInfo = &ForeignKeyDefinition{Source: yyDollar[5].columns, ReferencedTable: yyDollar[8].tableName, ReferencedColumns: yyDollar[10].columns, OnDelete: yyDollar[13].ReferenceAction, OnUpdate: yyDollar[12].ReferenceAction, Index: string(yyDollar[3].bytes)} } case 790: @@ -16957,32 +17623,73 @@ yydefault: case 791: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4172 +======= + yyVAL.val = &ForeignKeyDefinition{Source: yyDollar[5].val.(Columns), ReferencedTable: yyDollar[8].val.(TableName), ReferencedColumns: yyDollar[10].val.(Columns), OnDelete: yyDollar[13].val.(ReferenceAction), OnUpdate: yyDollar[12].val.(ReferenceAction), Index: string(yyDollar[3].bytes)} + } + case 790: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4083 + { + yyVAL.bytes = []byte(nil) + } + case 791: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4087 +>>>>>>> Stashed changes { yyVAL.bytes = yyDollar[1].bytes } case 792: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4178 +======= +//line sql3.y:4093 +>>>>>>> Stashed changes + { + yyVAL.val = &ConstraintDefinition{Name: string(yyDollar[2].bytes), Details: yyDollar[3].val.(ConstraintInfo)} + } + case 793: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4097 { - yyVAL.constraintDefinition = &ConstraintDefinition{Name: string(yyDollar[2].bytes), Details: yyDollar[3].constraintInfo} + yyVAL.val = &ConstraintDefinition{Details: yyDollar[2].val.(ConstraintInfo)} } +<<<<<<< Updated upstream case 793: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4182 +======= + case 794: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4101 +>>>>>>> Stashed changes { - yyVAL.constraintDefinition = &ConstraintDefinition{Details: yyDollar[2].constraintInfo} + yyVAL.val = &ConstraintDefinition{Details: yyDollar[1].val.(ConstraintInfo)} } +<<<<<<< Updated upstream case 794: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4186 +======= + case 795: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4107 +>>>>>>> Stashed changes { - yyVAL.constraintDefinition = &ConstraintDefinition{Details: yyDollar[1].constraintInfo} + yyVAL.val = &CheckConstraintDefinition{Expr: yyDollar[3].val.(Expr), Enforced: yyDollar[5].val.(bool)} } +<<<<<<< Updated upstream case 795: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4192 +======= + case 796: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4113 +>>>>>>> Stashed changes { - yyVAL.constraintInfo = &CheckConstraintDefinition{Expr: yyDollar[3].expr, Enforced: yyDollar[5].boolean} + yyVAL.val = string(yyDollar[1].bytes) } case 796: yyDollar = yyS[yypt-1 : yypt+1] @@ -16992,15 +17699,25 @@ yydefault: } case 797: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4202 +//line sql3.y:4117 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 798: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4207 +======= +//line sql3.y:4122 { - yyVAL.str = "" + yyVAL.val = "" + } + case 799: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4126 +>>>>>>> Stashed changes + { + yyVAL.val = string(yyDollar[2].bytes) } case 799: yyDollar = yyS[yypt-2 : yypt+1] @@ -17010,12 +17727,13 @@ yydefault: } case 800: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4215 +//line sql3.y:4130 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) } case 801: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4221 { yyVAL.ReferenceAction = yyDollar[3].ReferenceAction @@ -17023,19 +17741,35 @@ yydefault: case 802: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:4227 +======= +//line sql3.y:4136 { - yyVAL.ReferenceAction = yyDollar[3].ReferenceAction + yyVAL.val = yyDollar[3].val.(ReferenceAction) + } + case 802: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4142 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[3].val.(ReferenceAction) } case 803: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4233 { yyVAL.ReferenceAction = Restrict +======= +//line sql3.y:4148 + { + yyVAL.val = Restrict +>>>>>>> Stashed changes } case 804: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4237 +//line sql3.y:4152 { +<<<<<<< Updated upstream yyVAL.ReferenceAction = Cascade } case 805: @@ -17043,17 +17777,31 @@ yydefault: //line sql.y:4241 { yyVAL.ReferenceAction = NoAction +======= + yyVAL.val = Cascade + } + case 805: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4156 + { + yyVAL.val = NoAction +>>>>>>> Stashed changes } case 806: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4245 +//line sql3.y:4160 { +<<<<<<< Updated upstream yyVAL.ReferenceAction = SetDefault +======= + yyVAL.val = SetDefault +>>>>>>> Stashed changes } case 807: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4249 +//line sql3.y:4164 { +<<<<<<< Updated upstream yyVAL.ReferenceAction = SetNull } case 808: @@ -17065,32 +17813,69 @@ yydefault: case 809: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4258 +======= + yyVAL.val = SetNull + } + case 808: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4169 { - yyVAL.boolean = true + yyVAL.val = true + } + case 809: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4173 +>>>>>>> Stashed changes + { + yyVAL.val = true } case 810: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4262 +//line sql3.y:4177 { +<<<<<<< Updated upstream yyVAL.boolean = false } case 811: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4267 +======= + yyVAL.val = false + } + case 811: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4182 + { + yyVAL.val = []*TableOption(nil) + } + case 812: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4186 +>>>>>>> Stashed changes { - yyVAL.tableOptions = nil + yyVAL.val = append(yyDollar[1].val.([]*TableOption), yyDollar[2].val.(*TableOption)) } +<<<<<<< Updated upstream case 812: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4271 +======= + case 813: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4190 +>>>>>>> Stashed changes { - yyVAL.tableOptions = append(yyDollar[1].tableOptions, yyDollar[2].tableOption) + yyVAL.val = append(yyDollar[1].val.([]*TableOption), yyDollar[3].val.(*TableOption)) } case 813: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4275 +======= +//line sql3.y:4196 +>>>>>>> Stashed changes { - yyVAL.tableOptions = append(yyDollar[1].tableOptions, yyDollar[3].tableOption) + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} } case 814: yyDollar = yyS[yypt-3 : yypt+1] @@ -17100,27 +17885,43 @@ yydefault: } case 815: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4285 +//line sql3.y:4200 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} } case 816: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4289 +//line sql3.y:4204 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} } case 817: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4293 +======= +//line sql3.y:4208 + { + yyVAL.val = &TableOption{Name: "CHARACTER SET", Value: yyDollar[4].val.(string)} + } + case 818: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4212 +>>>>>>> Stashed changes { - yyVAL.tableOption = &TableOption{Name: "CHARACTER SET", Value: yyDollar[4].str} + yyVAL.val = &TableOption{Name: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: yyDollar[5].val.(string)} } +<<<<<<< Updated upstream case 818: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4297 +======= + case 819: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4216 +>>>>>>> Stashed changes { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Value: yyDollar[5].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 819: yyDollar = yyS[yypt-3 : yypt+1] @@ -17130,15 +17931,29 @@ yydefault: } case 820: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4305 +//line sql3.y:4220 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: "CHECKSUM", Value: string(yyDollar[3].bytes)} } case 821: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4309 +======= + yyVAL.val = &TableOption{Name: "CHECKSUM", Value: string(yyDollar[3].bytes)} + } + case 821: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4224 + { + yyVAL.val = &TableOption{Name: string(yyDollar[2].bytes), Value: yyDollar[4].val.(string)} + } + case 822: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4228 +>>>>>>> Stashed changes { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[2].bytes), Value: yyDollar[4].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 822: yyDollar = yyS[yypt-3 : yypt+1] @@ -17148,99 +17963,133 @@ yydefault: } case 823: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4317 +//line sql3.y:4232 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 824: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4321 +//line sql3.y:4236 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 825: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4325 { yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes)} +======= +//line sql3.y:4240 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes)} +>>>>>>> Stashed changes } case 826: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4329 +//line sql3.y:4244 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes) + " " + string(yyDollar[2].bytes), Value: string(yyDollar[4].bytes)} } case 827: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4333 { yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} +======= +//line sql3.y:4248 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} +>>>>>>> Stashed changes } case 828: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4337 +//line sql3.y:4252 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 829: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4341 +//line sql3.y:4256 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 830: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4345 +//line sql3.y:4260 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 831: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4349 +//line sql3.y:4264 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 832: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4353 +//line sql3.y:4268 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} +======= + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} +>>>>>>> Stashed changes } case 833: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4357 +//line sql3.y:4272 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} } case 834: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4361 +//line sql3.y:4276 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} } case 835: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4365 +//line sql3.y:4280 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} +======= + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} +>>>>>>> Stashed changes } case 836: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4369 +//line sql3.y:4284 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 837: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4373 +//line sql3.y:4288 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} } case 838: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4377 +======= + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} + } + case 838: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4292 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes) + string(yyDollar[2].bytes)} + } + case 839: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4296 +>>>>>>> Stashed changes { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes) + string(yyDollar[2].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 839: yyDollar = yyS[yypt-3 : yypt+1] @@ -17250,50 +18099,51 @@ yydefault: } case 840: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4385 +//line sql3.y:4300 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 841: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4389 +//line sql3.y:4304 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 842: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4393 +//line sql3.y:4308 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 843: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4397 +//line sql3.y:4312 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 844: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4401 +//line sql3.y:4316 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 845: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4405 +//line sql3.y:4320 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 846: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4409 +//line sql3.y:4324 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[3].bytes)} } case 847: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4413 +//line sql3.y:4328 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].str} } case 848: @@ -17301,11 +18151,21 @@ yydefault: //line sql.y:4417 { yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[2].str} +======= + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[3].val.(string)} + } + case 848: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4332 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: yyDollar[2].val.(string)} +>>>>>>> Stashed changes } case 849: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4421 +//line sql3.y:4336 { +<<<<<<< Updated upstream yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes)} } case 850: @@ -17313,15 +18173,25 @@ yydefault: //line sql.y:4425 { yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} +======= + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes)} + } + case 850: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4340 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} +>>>>>>> Stashed changes } case 851: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4429 +//line sql3.y:4344 { - yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} } case 852: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4433 { yyVAL.tableOption = &TableOption{Name: string(yyDollar[1].bytes), Value: "(" + yyDollar[4].str + ")"} @@ -17329,212 +18199,329 @@ yydefault: case 853: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4439 +======= +//line sql3.y:4348 + { + yyVAL.val = &TableOption{Name: string(yyDollar[1].bytes), Value: "(" + yyDollar[4].val.(string) + ")"} + } + case 853: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4354 +>>>>>>> Stashed changes { yyVAL.bytes = yyDollar[1].bytes } case 854: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4443 +//line sql3.y:4358 { yyVAL.bytes = yyDollar[1].bytes } case 855: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4447 +//line sql3.y:4362 { yyVAL.bytes = yyDollar[1].bytes } case 856: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4453 { yyVAL.str = string(yyDollar[1].bytes) +======= +//line sql3.y:4368 + { + yyVAL.val = string(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 857: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4457 +//line sql3.y:4372 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 858: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4463 { yyVAL.str = "'" + string(yyDollar[1].bytes) + "'" +======= +//line sql3.y:4378 + { + yyVAL.val = "'" + string(yyDollar[1].bytes) + "'" +>>>>>>> Stashed changes } case 859: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4467 +//line sql3.y:4382 { +<<<<<<< Updated upstream yyVAL.str = string(yyDollar[1].bytes) } case 860: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4472 +======= + yyVAL.val = string(yyDollar[1].bytes) + } + case 860: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4387 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 861: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4476 +//line sql3.y:4391 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 862: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4480 +//line sql3.y:4395 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 863: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4486 +======= +//line sql3.y:4401 +>>>>>>> Stashed changes { yyVAL.bytes = yyDollar[1].bytes } case 864: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4490 +//line sql3.y:4405 { yyVAL.bytes = yyDollar[1].bytes } case 865: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4494 +//line sql3.y:4409 { yyVAL.bytes = yyDollar[1].bytes } case 866: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4500 { yyVAL.str = string(yyDollar[1].bytes) +======= +//line sql3.y:4415 + { + yyVAL.val = string(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 867: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4504 +//line sql3.y:4419 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 868: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4508 +//line sql3.y:4423 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 869: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4512 +//line sql3.y:4427 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 870: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4516 +//line sql3.y:4431 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 871: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4520 +//line sql3.y:4435 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 872: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4526 +======= +//line sql3.y:4441 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 873: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4530 +======= +//line sql3.y:4445 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(string) + "," + string(yyDollar[3].bytes) + } + case 877: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4456 { - yyVAL.str = yyDollar[1].str + "," + string(yyDollar[3].bytes) + yyVAL.val = &PartitionOption{} } +<<<<<<< Updated upstream case 877: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4541 +======= + case 878: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:4460 +>>>>>>> Stashed changes { - yyVAL.partOption = nil + yyDollar[3].val.(*PartitionOption).Partitions = yyDollar[4].val.(*SQLVal) + yyDollar[3].val.(*PartitionOption).SubPartition = yyDollar[5].val.(*SubPartition) + yyDollar[3].val.(*PartitionOption).Definitions = yyDollar[6].val.([]*PartitionDefinition) + yyVAL.val = yyDollar[3].val.(*PartitionOption) } +<<<<<<< Updated upstream case 878: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:4545 +======= + case 879: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4469 +>>>>>>> Stashed changes { - yyDollar[3].partOption.Partitions = yyDollar[4].sqlVal - yyDollar[3].partOption.SubPartition = yyDollar[5].subpart - yyDollar[3].partOption.Definitions = yyDollar[6].partDefs - yyVAL.partOption = yyDollar[3].partOption + yyVAL.val = yyDollar[1].val.(*PartitionOption) } +<<<<<<< Updated upstream case 879: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4554 +======= + case 880: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4473 +>>>>>>> Stashed changes { - yyVAL.partOption = yyDollar[1].partOption + yyVAL.val = &PartitionOption{ + PartitionType: string(yyDollar[1].val.(string)), + Expr: yyDollar[3].val.(Expr), + } } +<<<<<<< Updated upstream case 880: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4558 +======= + case 881: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4480 +>>>>>>> Stashed changes { - yyVAL.partOption = &PartitionOption{ - PartitionType: string(yyDollar[1].str), - Expr: yyDollar[3].expr, + yyVAL.val = &PartitionOption{ + PartitionType: string(yyDollar[1].val.(string)), + ColList: yyDollar[4].val.(Columns), } } case 881: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4565 +======= +//line sql3.y:4489 +>>>>>>> Stashed changes { - yyVAL.partOption = &PartitionOption{ - PartitionType: string(yyDollar[1].str), - ColList: yyDollar[4].columns, + yyVAL.val = &PartitionOption{ + IsLinear: yyDollar[1].val.(bool), + PartitionType: string(yyDollar[2].bytes), + Expr: yyDollar[4].val.(Expr), } } +<<<<<<< Updated upstream case 882: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4574 +======= + case 883: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:4497 +>>>>>>> Stashed changes { - yyVAL.partOption = &PartitionOption{ - IsLinear: yyDollar[1].boolean, + yyVAL.val = &PartitionOption{ + IsLinear: yyDollar[1].val.(bool), PartitionType: string(yyDollar[2].bytes), - Expr: yyDollar[4].expr, + KeyAlgorithm: yyDollar[3].val.(string), + ColList: yyDollar[5].val.(Columns), } } +<<<<<<< Updated upstream case 883: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:4582 +======= + case 884: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4507 +>>>>>>> Stashed changes { - yyVAL.partOption = &PartitionOption{ - IsLinear: yyDollar[1].boolean, - PartitionType: string(yyDollar[2].bytes), - KeyAlgorithm: yyDollar[3].str, - ColList: yyDollar[5].columns, - } + yyVAL.val = false } +<<<<<<< Updated upstream case 884: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4592 +======= + case 885: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4511 +>>>>>>> Stashed changes { - yyVAL.boolean = false + yyVAL.val = true } +<<<<<<< Updated upstream case 885: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4596 +======= + case 886: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4516 +>>>>>>> Stashed changes { - yyVAL.boolean = true + yyVAL.val = "" } +<<<<<<< Updated upstream case 886: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4601 +======= + case 887: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4520 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = string(yyDollar[1].bytes) + " = " + string(yyDollar[3].bytes) } +<<<<<<< Updated upstream case 887: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:4605 +======= + case 888: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4526 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[1].bytes) + " = " + string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 888: yyDollar = yyS[yypt-1 : yypt+1] @@ -17544,63 +18531,110 @@ yydefault: } case 889: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:4615 +//line sql3.y:4530 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 890: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4620 +======= +//line sql3.y:4535 { - yyVAL.sqlVal = nil + yyVAL.val = &SQLVal{} } case 891: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4539 +>>>>>>> Stashed changes + { + yyVAL.val = NewIntVal(yyDollar[2].bytes) + } +<<<<<<< Updated upstream + case 891: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4624 +======= + case 892: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4544 +>>>>>>> Stashed changes { - yyVAL.sqlVal = NewIntVal(yyDollar[2].bytes) + yyVAL.val = &SubPartition{} } +<<<<<<< Updated upstream case 892: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4629 +======= + case 893: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:4548 +>>>>>>> Stashed changes { - yyVAL.subpart = nil + yyVAL.val = &SubPartition{ + IsLinear: yyDollar[3].val.(bool), + PartitionType: string(yyDollar[4].bytes), + Expr: yyDollar[6].val.(Expr), + SubPartitions: yyDollar[8].val.(*SQLVal), + } } +<<<<<<< Updated upstream case 893: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:4633 +======= + case 894: + yyDollar = yyS[yypt-9 : yypt+1] +//line sql3.y:4557 +>>>>>>> Stashed changes { - yyVAL.subpart = &SubPartition{ - IsLinear: yyDollar[3].boolean, + yyVAL.val = &SubPartition{ + IsLinear: yyDollar[3].val.(bool), PartitionType: string(yyDollar[4].bytes), - Expr: yyDollar[6].expr, - SubPartitions: yyDollar[8].sqlVal, + KeyAlgorithm: yyDollar[5].val.(string), + Expr: yyDollar[7].val.(Expr), + SubPartitions: yyDollar[9].val.(*SQLVal), } } +<<<<<<< Updated upstream case 894: yyDollar = yyS[yypt-9 : yypt+1] //line sql.y:4642 +======= + case 895: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4568 +>>>>>>> Stashed changes { - yyVAL.subpart = &SubPartition{ - IsLinear: yyDollar[3].boolean, - PartitionType: string(yyDollar[4].bytes), - KeyAlgorithm: yyDollar[5].str, - Expr: yyDollar[7].expr, - SubPartitions: yyDollar[9].sqlVal, - } + yyVAL.val = &SQLVal{} } +<<<<<<< Updated upstream case 895: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4653 +======= + case 896: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4572 +>>>>>>> Stashed changes { - yyVAL.sqlVal = nil + yyVAL.val = NewIntVal(yyDollar[2].bytes) } +<<<<<<< Updated upstream case 896: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4657 +======= + case 897: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4577 +>>>>>>> Stashed changes { - yyVAL.sqlVal = NewIntVal(yyDollar[2].bytes) + yyVAL.val = "" } +<<<<<<< Updated upstream case 897: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4662 @@ -17610,15 +18644,31 @@ yydefault: case 898: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4666 +======= + case 898: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4581 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = "" } case 899: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4670 +======= +//line sql3.y:4585 { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) + } + case 900: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:4590 +>>>>>>> Stashed changes + { + yyVAL.val = string("") } +<<<<<<< Updated upstream case 900: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:4675 @@ -17628,15 +18678,33 @@ yydefault: case 901: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:4679 +======= + case 901: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4594 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = string(yyDollar[2].bytes) + } + case 906: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4606 + { + yyVAL.val = &DBDDL{Action: AlterStr, SchemaOrDatabase: "database", DBName: string(yyDollar[3].bytes), CharsetCollate: yyDollar[4].val.([]*CharsetAndCollate)} } +<<<<<<< Updated upstream case 906: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4691 +======= + case 907: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4610 +>>>>>>> Stashed changes { - yyVAL.statement = &DBDDL{Action: AlterStr, SchemaOrDatabase: "database", DBName: string(yyDollar[3].bytes), CharsetCollate: yyDollar[4].charsetCollates} + yyVAL.val = &DBDDL{Action: AlterStr, SchemaOrDatabase: "database", CharsetCollate: yyDollar[3].val.([]*CharsetAndCollate)} } +<<<<<<< Updated upstream case 907: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:4695 @@ -17646,47 +18714,91 @@ yydefault: case 908: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:4701 +======= + case 908: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:4616 +>>>>>>> Stashed changes { - for i := 0; i < len(yyDollar[5].ddls); i++ { - if yyDollar[5].ddls[i].Action == RenameStr { - yyDollar[5].ddls[i].FromTables = append(TableNames{yyDollar[4].tableName}, yyDollar[5].ddls[i].FromTables...) + for i := 0; i < len(yyDollar[5].val.([]*DDL)); i++ { + if yyDollar[5].val.([]*DDL)[i].Action == RenameStr { + yyDollar[5].val.([]*DDL)[i].FromTables = append(TableNames{yyDollar[4].val.(TableName)}, yyDollar[5].val.([]*DDL)[i].FromTables...) } else { - yyDollar[5].ddls[i].Table = yyDollar[4].tableName + yyDollar[5].val.([]*DDL)[i].Table = yyDollar[4].val.(TableName) } } - yyVAL.statement = &AlterTable{Table: yyDollar[4].tableName, Statements: yyDollar[5].ddls, PartitionSpecs: yyDollar[6].partSpecs} + yyVAL.val = &AlterTable{Table: yyDollar[4].val.(TableName), Statements: yyDollar[5].val.([]*DDL), PartitionSpecs: yyDollar[6].val.([]*PartitionSpec)} + } + case 909: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4627 + { + yyVAL.val = &AlterTable{Table: yyDollar[4].val.(TableName), PartitionSpecs: yyDollar[5].val.([]*PartitionSpec)} } +<<<<<<< Updated upstream case 909: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4712 +======= + case 910: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4633 +>>>>>>> Stashed changes { - yyVAL.statement = &AlterTable{Table: yyDollar[4].tableName, PartitionSpecs: yyDollar[5].partSpecs} + yyVAL.val = []*DDL{yyDollar[1].val.(*DDL)} } +<<<<<<< Updated upstream case 910: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:4718 +======= + case 911: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4637 +>>>>>>> Stashed changes { - yyVAL.ddls = []*DDL{yyDollar[1].ddl} + yyVAL.val = append(yyVAL.val.([]*DDL), yyDollar[3].val.(*DDL)) } +<<<<<<< Updated upstream case 911: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:4722 +======= + case 912: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4643 +>>>>>>> Stashed changes { - yyVAL.ddls = append(yyVAL.ddls, yyDollar[3].ddl) + ddl := &DDL{ + Action: AlterStr, + ColumnAction: AddStr, + TableSpec: &TableSpec{}, + } + ddl.TableSpec.AddColumn(yyDollar[4].val.(*ColumnDefinition)) + ddl.Column = yyDollar[4].val.(*ColumnDefinition).Name + yyVAL.val = ddl } +<<<<<<< Updated upstream case 912: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4728 +======= + case 913: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4654 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, ColumnAction: AddStr, TableSpec: &TableSpec{}, + ColumnOrder: yyDollar[4].val.(*ColumnOrder), } - ddl.TableSpec.AddColumn(yyDollar[4].columnDefinition) - ddl.Column = yyDollar[4].columnDefinition.Name - yyVAL.ddl = ddl + ddl.TableSpec.AddColumn(yyDollar[3].val.(*ColumnDefinition)) + ddl.Column = yyDollar[3].val.(*ColumnDefinition).Name + yyVAL.val = ddl } +<<<<<<< Updated upstream case 913: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4739 @@ -17704,41 +18816,54 @@ yydefault: case 914: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:4751 +======= + case 914: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:4666 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: CreateStr, - ToName: NewColIdent(yyDollar[3].str), - Using: yyDollar[4].colIdent, - Columns: yyDollar[6].indexColumns, - Options: yyDollar[8].indexOptions, + ToName: NewColIdent(yyDollar[3].val.(string)), + Using: yyDollar[4].val.(ColIdent), + Columns: yyDollar[6].val.([]*IndexColumn), + Options: yyDollar[8].val.([]*IndexOption), }, } } case 915: yyDollar = yyS[yypt-10 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4764 +======= +//line sql3.y:4679 +>>>>>>> Stashed changes { - idxName := yyDollar[5].str + idxName := yyDollar[5].val.(string) if len(idxName) == 0 { - idxName = yyDollar[2].str + idxName = yyDollar[2].val.(string) } - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: CreateStr, ToName: NewColIdent(idxName), - Type: yyDollar[3].str, - Using: yyDollar[6].colIdent, - Columns: yyDollar[8].indexColumns, - Options: yyDollar[10].indexOptions, + Type: yyDollar[3].val.(string), + Using: yyDollar[6].val.(ColIdent), + Columns: yyDollar[8].val.([]*IndexColumn), + Options: yyDollar[10].val.([]*IndexOption), }, } } case 916: yyDollar = yyS[yypt-9 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4784 +======= +//line sql3.y:4699 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, @@ -17749,12 +18874,24 @@ yydefault: ddl.IndexSpec = &IndexSpec{ Action: CreateStr, Using: NewColIdent(""), - ToName: NewColIdent(yyDollar[2].str), + ToName: NewColIdent(yyDollar[2].val.(string)), Type: PrimaryStr, - Columns: yyDollar[7].indexColumns, - Options: yyDollar[9].indexOptions, + Columns: yyDollar[7].val.([]*IndexColumn), + Options: yyDollar[9].val.([]*IndexOption), } - yyVAL.ddl = ddl + yyVAL.val = ddl + } + case 917: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4717 + { + ddl := &DDL{ + Action: AlterStr, + ConstraintAction: AddStr, + TableSpec: &TableSpec{}, + } + ddl.TableSpec.AddConstraint(yyDollar[2].val.(*ConstraintDefinition)) + yyVAL.val = ddl } case 917: yyDollar = yyS[yypt-2 : yypt+1] @@ -17770,21 +18907,29 @@ yydefault: } case 918: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4812 +======= +//line sql3.y:4727 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, ConstraintAction: AddStr, TableSpec: &TableSpec{}, } - ddl.TableSpec.AddConstraint(yyDollar[2].constraintDefinition) - yyVAL.ddl = ddl + ddl.TableSpec.AddConstraint(yyDollar[2].val.(*ConstraintDefinition)) + yyVAL.val = ddl } case 919: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4822 +======= +//line sql3.y:4737 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, ConstraintAction: DropStr, TableSpec: &TableSpec{ @@ -17798,9 +18943,13 @@ yydefault: } case 920: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4836 +======= +//line sql3.y:4751 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, ConstraintAction: DropStr, TableSpec: &TableSpec{ @@ -17815,77 +18964,103 @@ yydefault: } case 921: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4851 { yyVAL.ddl = &DDL{Action: AlterStr} +======= +//line sql3.y:4766 + { + yyVAL.val = &DDL{Action: AlterStr} +>>>>>>> Stashed changes } case 922: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4855 +//line sql3.y:4770 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 923: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4859 +//line sql3.y:4774 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 924: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4863 +//line sql3.y:4778 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 925: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4867 +======= +//line sql3.y:4782 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 926: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4871 +//line sql3.y:4786 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 927: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4875 +//line sql3.y:4790 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 928: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:4879 +//line sql3.y:4794 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 929: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4883 +======= +//line sql3.y:4798 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, DefaultSpec: &DefaultSpec{ Action: SetStr, - Column: yyDollar[3].colIdent, - Value: yyDollar[6].expr, + Column: yyDollar[3].val.(ColIdent), + Value: yyDollar[6].val.(Expr), }, } } case 930: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:4894 +//line sql3.y:4809 { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, DefaultSpec: &DefaultSpec{ Action: DropStr, - Column: yyDollar[3].colIdent, + Column: yyDollar[3].val.(ColIdent), }, } } +<<<<<<< Updated upstream + case 930: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql.y:4894 +======= + case 931: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4819 +>>>>>>> Stashed changes + { + yyVAL.val = &DDL{Action: AlterStr} + } case 931: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4904 @@ -17894,48 +19069,73 @@ yydefault: } case 932: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:4908 +//line sql3.y:4823 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 933: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4912 +======= +//line sql3.y:4827 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, ColumnAction: ChangeStr, TableSpec: &TableSpec{}, Column: NewColIdent(string(yyDollar[3].bytes)), - ColumnOrder: yyDollar[5].columnOrder, + ColumnOrder: yyDollar[5].val.(*ColumnOrder), } - ddl.TableSpec.AddColumn(yyDollar[4].columnDefinition) - yyVAL.ddl = ddl + ddl.TableSpec.AddColumn(yyDollar[4].val.(*ColumnDefinition)) + yyVAL.val = ddl } case 934: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4924 +======= +//line sql3.y:4839 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, AlterCollationSpec: &AlterCollationSpec{ - CharacterSet: yyDollar[5].str, + CharacterSet: yyDollar[5].val.(string), Collation: "", }, } } case 935: yyDollar = yyS[yypt-8 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4934 +======= +//line sql3.y:4849 { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ + Action: AlterStr, + AlterCollationSpec: &AlterCollationSpec{ + CharacterSet: yyDollar[5].val.(string), + Collation: yyDollar[8].val.(string), + }, + } + } + case 936: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:4859 +>>>>>>> Stashed changes + { + yyVAL.val = &DDL{ Action: AlterStr, AlterCollationSpec: &AlterCollationSpec{ - CharacterSet: yyDollar[5].str, - Collation: yyDollar[8].str, + CharacterSet: "", + Collation: yyDollar[4].val.(string), }, } } +<<<<<<< Updated upstream case 936: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:4944 @@ -17951,24 +19151,44 @@ yydefault: case 937: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:4954 +======= + case 937: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:4869 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, AlterCollationSpec: &AlterCollationSpec{ - CharacterSet: yyDollar[5].str, + CharacterSet: yyDollar[5].val.(string), Collation: "", }, } } case 938: yyDollar = yyS[yypt-7 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4964 +======= +//line sql3.y:4879 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, AlterCollationSpec: &AlterCollationSpec{ - CharacterSet: yyDollar[5].str, - Collation: yyDollar[7].str, + CharacterSet: yyDollar[5].val.(string), + Collation: yyDollar[7].val.(string), + }, + } + } + case 939: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:4889 + { + yyVAL.val = &DDL{ + Action: AlterStr, + IndexSpec: &IndexSpec{ + Action: string(yyDollar[1].bytes), }, } } @@ -17985,9 +19205,13 @@ yydefault: } case 940: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4983 +======= +//line sql3.y:4898 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: string(yyDollar[1].bytes), @@ -17996,21 +19220,31 @@ yydefault: } case 941: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:4992 { yyVAL.ddl = &DDL{Action: AlterStr} +======= +//line sql3.y:4907 + { + yyVAL.val = &DDL{Action: AlterStr} +>>>>>>> Stashed changes } case 942: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:4996 +//line sql3.y:4911 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 943: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5000 +======= +//line sql3.y:4915 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, ColumnAction: DropStr, Column: NewColIdent(string(yyDollar[3].bytes)), @@ -18018,21 +19252,29 @@ yydefault: } case 944: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5008 +======= +//line sql3.y:4923 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: DropStr, - ToName: yyDollar[3].colIdent, + ToName: yyDollar[3].val.(ColIdent), }, } } case 945: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5018 +======= +//line sql3.y:4933 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: DropStr, @@ -18042,7 +19284,11 @@ yydefault: } case 946: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5028 +======= +//line sql3.y:4943 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, @@ -18053,8 +19299,15 @@ yydefault: Name: string(yyDollar[4].bytes), Details: &ForeignKeyDefinition{}, }) - yyVAL.ddl = ddl + yyVAL.val = ddl + } + case 947: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:4956 + { + yyVAL.val = &DDL{Action: AlterStr} } +<<<<<<< Updated upstream case 947: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5041 @@ -18064,46 +19317,59 @@ yydefault: case 948: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5045 +======= + case 948: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:4960 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 949: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5049 +//line sql3.y:4964 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 950: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5053 +//line sql3.y:4968 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 951: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5057 +//line sql3.y:4972 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 952: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5061 +======= +//line sql3.y:4976 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, ColumnAction: ModifyStr, TableSpec: &TableSpec{}, - ColumnOrder: yyDollar[4].columnOrder, + ColumnOrder: yyDollar[4].val.(*ColumnOrder), } - ddl.TableSpec.AddColumn(yyDollar[3].columnDefinition) - ddl.Column = yyDollar[3].columnDefinition.Name - yyVAL.ddl = ddl + ddl.TableSpec.AddColumn(yyDollar[3].val.(*ColumnDefinition)) + ddl.Column = yyDollar[3].val.(*ColumnDefinition).Name + yyVAL.val = ddl } case 953: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5074 +======= +//line sql3.y:4989 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, ColumnAction: RenameStr, Column: NewColIdent(string(yyDollar[3].bytes)), @@ -18112,30 +19378,42 @@ yydefault: } case 954: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5083 +======= +//line sql3.y:4998 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, IndexSpec: &IndexSpec{ Action: RenameStr, - FromName: yyDollar[3].colIdent, - ToName: yyDollar[5].colIdent, + FromName: yyDollar[3].val.(ColIdent), + ToName: yyDollar[5].val.(ColIdent), }, } } case 955: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5094 +======= +//line sql3.y:5009 +>>>>>>> Stashed changes { // Change this to a rename statement - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: RenameStr, - ToTables: TableNames{yyDollar[3].tableName}, + ToTables: TableNames{yyDollar[3].val.(TableName)}, } } case 956: yyDollar = yyS[yypt-7 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5102 +======= +//line sql3.y:5017 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, @@ -18150,11 +19428,15 @@ yydefault: Name: string(yyDollar[7].bytes), Details: &ForeignKeyDefinition{}, }) - yyVAL.ddl = ddl + yyVAL.val = ddl } case 957: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5119 +======= +//line sql3.y:5034 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, @@ -18169,11 +19451,15 @@ yydefault: Name: string(yyDollar[6].bytes), Details: &CheckConstraintDefinition{}, }) - yyVAL.ddl = ddl + yyVAL.val = ddl } case 958: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5136 +======= +//line sql3.y:5051 +>>>>>>> Stashed changes { ddl := &DDL{ Action: AlterStr, @@ -18186,21 +19472,35 @@ yydefault: ddl.TableSpec.AddConstraint(&ConstraintDefinition{ Name: string(yyDollar[5].bytes), }) - yyVAL.ddl = ddl + yyVAL.val = ddl } case 959: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5151 +======= +//line sql3.y:5066 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{ + yyVAL.val = &DDL{ Action: AlterStr, } } case 960: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5157 +======= +//line sql3.y:5072 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(*DDL) + } + case 961: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5079 { - yyVAL.ddl = yyDollar[1].ddl + yyVAL.val = &DDL{Action: AlterStr} } case 961: yyDollar = yyS[yypt-3 : yypt+1] @@ -18210,248 +19510,314 @@ yydefault: } case 962: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5168 +//line sql3.y:5083 { +<<<<<<< Updated upstream yyVAL.ddl = &DDL{Action: AlterStr, AutoIncSpec: &AutoIncSpec{Value: yyDollar[3].expr}} +======= + yyVAL.val = &DDL{Action: AlterStr, AutoIncSpec: &AutoIncSpec{Value: yyDollar[3].val.(Expr)}} +>>>>>>> Stashed changes } case 963: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5172 +//line sql3.y:5087 { +<<<<<<< Updated upstream yyVAL.ddl = &DDL{Action: AlterStr} +======= + yyVAL.val = &DDL{Action: AlterStr} +>>>>>>> Stashed changes } case 964: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5176 +//line sql3.y:5091 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 965: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5180 +//line sql3.y:5095 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 966: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5184 +//line sql3.y:5099 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 967: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5188 +//line sql3.y:5103 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 968: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5192 +//line sql3.y:5107 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 969: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5196 +======= +//line sql3.y:5111 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 970: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5200 +//line sql3.y:5115 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 971: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5204 +======= +//line sql3.y:5119 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 972: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5208 +//line sql3.y:5123 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 973: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5212 +//line sql3.y:5127 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 974: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5216 +//line sql3.y:5131 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 975: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5220 +//line sql3.y:5135 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 976: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5224 +//line sql3.y:5139 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 977: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5228 +//line sql3.y:5143 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 978: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5232 +//line sql3.y:5147 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 979: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5236 +//line sql3.y:5151 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 980: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5240 +//line sql3.y:5155 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 981: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5244 +//line sql3.y:5159 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 982: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5248 +//line sql3.y:5163 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 983: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5252 +//line sql3.y:5167 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 984: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5256 +//line sql3.y:5171 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 985: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5260 +//line sql3.y:5175 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 986: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5264 +//line sql3.y:5179 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 987: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5268 +//line sql3.y:5183 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 988: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5272 +//line sql3.y:5187 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 989: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5276 +//line sql3.y:5191 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 990: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5280 +//line sql3.y:5195 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 991: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5284 +======= +//line sql3.y:5199 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 992: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5288 +//line sql3.y:5203 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 993: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5292 +======= +//line sql3.y:5207 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 994: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5296 +//line sql3.y:5211 { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 995: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5300 +======= +//line sql3.y:5215 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: AlterStr} + yyVAL.val = &DDL{Action: AlterStr} } case 996: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5306 { yyVAL.boolean = true +======= +//line sql3.y:5221 + { + yyVAL.val = true +>>>>>>> Stashed changes } case 997: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5310 +//line sql3.y:5225 { +<<<<<<< Updated upstream yyVAL.boolean = false } case 1000: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5320 +======= + yyVAL.val = false + } + case 1000: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5235 +>>>>>>> Stashed changes { var ifExists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { ifExists = true } - yyVAL.statement = &DDL{Action: AlterStr, User: yyDollar[4].accountName, Authentication: yyDollar[5].authentication, IfExists: ifExists} + yyVAL.val = &DDL{Action: AlterStr, User: yyDollar[4].val.(AccountName), Authentication: yyDollar[5].val.(*Authentication), IfExists: ifExists} + } + case 1001: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5244 + { + yyVAL.val = &ColumnOrder{} } +<<<<<<< Updated upstream case 1001: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5329 +======= + case 1002: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5248 +>>>>>>> Stashed changes { - yyVAL.columnOrder = nil + yyVAL.val = &ColumnOrder{First: true} } +<<<<<<< Updated upstream case 1002: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5333 +======= + case 1003: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5252 +>>>>>>> Stashed changes { - yyVAL.columnOrder = &ColumnOrder{First: true} + yyVAL.val = &ColumnOrder{AfterColumn: NewColIdent(string(yyDollar[2].bytes))} } +<<<<<<< Updated upstream case 1003: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5337 +======= + case 1004: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5257 +>>>>>>> Stashed changes { - yyVAL.columnOrder = &ColumnOrder{AfterColumn: NewColIdent(string(yyDollar[2].bytes))} } +<<<<<<< Updated upstream case 1004: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5342 @@ -18460,43 +19826,86 @@ yydefault: case 1005: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5344 +======= + case 1005: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5259 +>>>>>>> Stashed changes { } case 1006: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5347 +======= +//line sql3.y:5262 + { + yyVAL.val = []*PartitionSpec(nil) + } + case 1007: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5266 +>>>>>>> Stashed changes { - yyVAL.partSpecs = nil + yyVAL.val = yyDollar[1].val.([]*PartitionSpec) } case 1007: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5351 +======= +//line sql3.y:5272 +>>>>>>> Stashed changes { - yyVAL.partSpecs = yyDollar[1].partSpecs + yyVAL.val = []*PartitionSpec{yyDollar[1].val.(*PartitionSpec)} } +<<<<<<< Updated upstream case 1008: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5357 - { - yyVAL.partSpecs = []*PartitionSpec{yyDollar[1].partSpec} +======= + case 1009: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5276 +>>>>>>> Stashed changes + { + yyVAL.val = append(yyDollar[1].val.([]*PartitionSpec), yyDollar[2].val.(*PartitionSpec)) } +<<<<<<< Updated upstream case 1009: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5361 +======= + case 1010: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5282 +>>>>>>> Stashed changes { - yyVAL.partSpecs = append(yyDollar[1].partSpecs, yyDollar[2].partSpec) + yyVAL.val = &PartitionSpec{Action: AddStr, Definitions: yyDollar[4].val.([]*PartitionDefinition)} } +<<<<<<< Updated upstream case 1010: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5367 +======= + case 1011: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5286 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: AddStr, Definitions: yyDollar[4].partDefs} + yyVAL.val = &PartitionSpec{Action: DropStr, Names: yyDollar[3].val.(Partitions)} } +<<<<<<< Updated upstream case 1011: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5371 +======= + case 1012: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5290 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: DropStr, Names: yyDollar[3].partitions} + yyVAL.val = &PartitionSpec{Action: DiscardStr, Names: yyDollar[3].val.(Partitions)} } case 1012: yyDollar = yyS[yypt-4 : yypt+1] @@ -18506,57 +19915,105 @@ yydefault: } case 1013: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5379 +//line sql3.y:5294 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: DiscardStr, IsAll: true} +======= + yyVAL.val = &PartitionSpec{Action: DiscardStr, IsAll: true} +>>>>>>> Stashed changes } case 1014: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5383 +//line sql3.y:5298 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: ImportStr, Names: yyDollar[3].partitions} +======= + yyVAL.val = &PartitionSpec{Action: ImportStr, Names: yyDollar[3].val.(Partitions)} +>>>>>>> Stashed changes } case 1015: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5387 +//line sql3.y:5302 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: ImportStr, IsAll: true} +======= + yyVAL.val = &PartitionSpec{Action: ImportStr, IsAll: true} +>>>>>>> Stashed changes } case 1016: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5391 +//line sql3.y:5306 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: TruncateStr, Names: yyDollar[3].partitions} +======= + yyVAL.val = &PartitionSpec{Action: TruncateStr, Names: yyDollar[3].val.(Partitions)} +>>>>>>> Stashed changes } case 1017: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5395 +//line sql3.y:5310 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: TruncateStr, IsAll: true} } case 1018: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5399 +======= + yyVAL.val = &PartitionSpec{Action: TruncateStr, IsAll: true} + } + case 1018: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5314 + { + yyVAL.val = &PartitionSpec{Action: CoalesceStr, Number: NewIntVal(yyDollar[3].bytes)} + } + case 1019: + yyDollar = yyS[yypt-7 : yypt+1] +//line sql3.y:5318 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: CoalesceStr, Number: NewIntVal(yyDollar[3].bytes)} + yyVAL.val = &PartitionSpec{Action: ReorganizeStr, Names: yyDollar[3].val.(Partitions), Definitions: yyDollar[6].val.([]*PartitionDefinition)} } +<<<<<<< Updated upstream case 1019: yyDollar = yyS[yypt-7 : yypt+1] //line sql.y:5403 +======= + case 1020: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:5322 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: ReorganizeStr, Names: yyDollar[3].partitions, Definitions: yyDollar[6].partDefs} + yyVAL.val = &PartitionSpec{Action: ExchangeStr, Names: Partitions{yyDollar[3].val.(ColIdent)}, TableName: yyDollar[6].val.(TableName)} } +<<<<<<< Updated upstream case 1020: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:5407 +======= + case 1021: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:5326 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: ExchangeStr, Names: Partitions{yyDollar[3].colIdent}, TableName: yyDollar[6].tableName} + yyVAL.val = &PartitionSpec{Action: ExchangeStr, Names: Partitions{yyDollar[3].val.(ColIdent)}, TableName: yyDollar[6].val.(TableName), WithValidation: yyDollar[7].val.(bool)} } +<<<<<<< Updated upstream case 1021: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:5411 +======= + case 1022: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5330 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: ExchangeStr, Names: Partitions{yyDollar[3].colIdent}, TableName: yyDollar[6].tableName, WithValidation: yyDollar[7].boolean} + yyVAL.val = &PartitionSpec{Action: AnalyzeStr, Names: yyDollar[3].val.(Partitions)} } case 1022: yyDollar = yyS[yypt-3 : yypt+1] @@ -18566,8 +20023,9 @@ yydefault: } case 1023: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5419 +//line sql3.y:5334 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: AnalyzeStr, IsAll: true} } case 1024: @@ -18575,66 +20033,129 @@ yydefault: //line sql.y:5432 { yyVAL.partSpec = &PartitionSpec{Action: OptimizeStr, Names: yyDollar[3].partitions} +======= + yyVAL.val = &PartitionSpec{Action: AnalyzeStr, IsAll: true} + } + case 1024: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5347 + { + yyVAL.val = &PartitionSpec{Action: OptimizeStr, Names: yyDollar[3].val.(Partitions)} +>>>>>>> Stashed changes } case 1025: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5436 +//line sql3.y:5351 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: OptimizeStr, IsAll: true} +======= + yyVAL.val = &PartitionSpec{Action: OptimizeStr, IsAll: true} +>>>>>>> Stashed changes } case 1026: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5440 +//line sql3.y:5355 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: RebuildStr, Names: yyDollar[3].partitions} +======= + yyVAL.val = &PartitionSpec{Action: RebuildStr, Names: yyDollar[3].val.(Partitions)} +>>>>>>> Stashed changes } case 1027: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5444 +//line sql3.y:5359 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: RebuildStr, IsAll: true} +======= + yyVAL.val = &PartitionSpec{Action: RebuildStr, IsAll: true} +>>>>>>> Stashed changes } case 1028: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5448 +//line sql3.y:5363 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: RepairStr, Names: yyDollar[3].partitions} +======= + yyVAL.val = &PartitionSpec{Action: RepairStr, Names: yyDollar[3].val.(Partitions)} +>>>>>>> Stashed changes } case 1029: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5452 +//line sql3.y:5367 { +<<<<<<< Updated upstream yyVAL.partSpec = &PartitionSpec{Action: RepairStr, IsAll: true} } case 1030: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5456 +======= + yyVAL.val = &PartitionSpec{Action: RepairStr, IsAll: true} + } + case 1030: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5371 + { + yyVAL.val = &PartitionSpec{Action: RemoveStr} + } + case 1031: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5376 +>>>>>>> Stashed changes { - yyVAL.partSpec = &PartitionSpec{Action: RemoveStr} + yyVAL.val = []*PartitionDefinition(nil) } +<<<<<<< Updated upstream case 1031: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5461 +======= + case 1032: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5380 +>>>>>>> Stashed changes { - yyVAL.partDefs = nil + yyVAL.val = yyDollar[2].val.([]*PartitionDefinition) } +<<<<<<< Updated upstream case 1032: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5465 +======= + case 1033: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5386 +>>>>>>> Stashed changes { - yyVAL.partDefs = yyDollar[2].partDefs + yyVAL.val = []*PartitionDefinition{yyDollar[1].val.(*PartitionDefinition)} } +<<<<<<< Updated upstream case 1033: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5471 +======= + case 1034: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5390 +>>>>>>> Stashed changes { - yyVAL.partDefs = []*PartitionDefinition{yyDollar[1].partDef} + yyVAL.val = append(yyDollar[1].val.([]*PartitionDefinition), yyDollar[3].val.(*PartitionDefinition)) } +<<<<<<< Updated upstream case 1034: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5475 +======= + case 1035: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:5396 +>>>>>>> Stashed changes { - yyVAL.partDefs = append(yyDollar[1].partDefs, yyDollar[3].partDef) + yyVAL.val = &PartitionDefinition{Name: yyDollar[2].val.(ColIdent), Limit: yyDollar[7].val.(Expr)} } case 1035: yyDollar = yyS[yypt-8 : yypt+1] @@ -18644,8 +20165,9 @@ yydefault: } case 1036: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:5485 +//line sql3.y:5400 { +<<<<<<< Updated upstream yyVAL.partDef = &PartitionDefinition{Name: yyDollar[2].colIdent, Maxvalue: true} } case 1037: @@ -18653,41 +20175,84 @@ yydefault: //line sql.y:5491 { es := &EventSpec{EventName: yyDollar[4].eventName, Definer: yyDollar[2].str, OnCompletionPreserve: yyDollar[5].eventOnCompletion, RenameName: yyDollar[6].eventName, Status: yyDollar[7].eventStatus, Comment: yyDollar[8].sqlVal} +======= + yyVAL.val = &PartitionDefinition{Name: yyDollar[2].val.(ColIdent), Maxvalue: true} + } + case 1037: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:5406 + { + es := &EventSpec{EventName: yyDollar[4].val.(EventName), Definer: yyDollar[2].val.(string), OnCompletionPreserve: yyDollar[5].val.(EventOnCompletion), RenameName: yyDollar[6].val.(EventName), Status: yyDollar[7].val.(EventStatus), Comment: yyDollar[8].val.(*SQLVal)} +>>>>>>> Stashed changes if err := es.ValidateAlterEvent(); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.statement = &DDL{Action: AlterStr, EventSpec: es} + yyVAL.val = &DDL{Action: AlterStr, EventSpec: es} + } + case 1038: + yyDollar = yyS[yypt-11 : yypt+1] +//line sql3.y:5415 + { + yyVAL.val = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].val.(EventName), Definer: yyDollar[2].val.(string), OnSchedule: yyDollar[7].val.(*EventScheduleSpec), OnCompletionPreserve: yyDollar[8].val.(EventOnCompletion), RenameName: yyDollar[9].val.(EventName), Status: yyDollar[10].val.(EventStatus), Comment: yyDollar[11].val.(*SQLVal)}} } +<<<<<<< Updated upstream case 1038: yyDollar = yyS[yypt-11 : yypt+1] //line sql.y:5500 +======= + case 1039: + yyDollar = yyS[yypt-12 : yypt+1] +//line sql3.y:5419 +>>>>>>> Stashed changes { - yyVAL.statement = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].eventName, Definer: yyDollar[2].str, OnSchedule: yyDollar[7].eventScheduleSpec, OnCompletionPreserve: yyDollar[8].eventOnCompletion, RenameName: yyDollar[9].eventName, Status: yyDollar[10].eventStatus, Comment: yyDollar[11].sqlVal}} + yyVAL.val = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].val.(EventName), Definer: yyDollar[2].val.(string), OnCompletionPreserve: yyDollar[5].val.(EventOnCompletion), RenameName: yyDollar[6].val.(EventName), Status: yyDollar[7].val.(EventStatus), Comment: yyDollar[8].val.(*SQLVal), Body: yyDollar[11].val.(Statement)}, SubStatementPositionStart: yyDollar[10].val.(int), SubStatementPositionEnd: yyDollar[12].val.(int) - 1} } +<<<<<<< Updated upstream case 1039: yyDollar = yyS[yypt-12 : yypt+1] //line sql.y:5504 +======= + case 1040: + yyDollar = yyS[yypt-15 : yypt+1] +//line sql3.y:5423 +>>>>>>> Stashed changes { - yyVAL.statement = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].eventName, Definer: yyDollar[2].str, OnCompletionPreserve: yyDollar[5].eventOnCompletion, RenameName: yyDollar[6].eventName, Status: yyDollar[7].eventStatus, Comment: yyDollar[8].sqlVal, Body: yyDollar[11].statement}, SubStatementPositionStart: yyDollar[10].int, SubStatementPositionEnd: yyDollar[12].int - 1} + yyVAL.val = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].val.(EventName), Definer: yyDollar[2].val.(string), OnSchedule: yyDollar[7].val.(*EventScheduleSpec), OnCompletionPreserve: yyDollar[8].val.(EventOnCompletion), RenameName: yyDollar[9].val.(EventName), Status: yyDollar[10].val.(EventStatus), Comment: yyDollar[11].val.(*SQLVal), Body: yyDollar[14].val.(Statement)}, SubStatementPositionStart: yyDollar[13].val.(int), SubStatementPositionEnd: yyDollar[15].val.(int) - 1} } +<<<<<<< Updated upstream case 1040: yyDollar = yyS[yypt-15 : yypt+1] //line sql.y:5508 +======= + case 1041: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5428 +>>>>>>> Stashed changes { - yyVAL.statement = &DDL{Action: AlterStr, EventSpec: &EventSpec{EventName: yyDollar[4].eventName, Definer: yyDollar[2].str, OnSchedule: yyDollar[7].eventScheduleSpec, OnCompletionPreserve: yyDollar[8].eventOnCompletion, RenameName: yyDollar[9].eventName, Status: yyDollar[10].eventStatus, Comment: yyDollar[11].sqlVal, Body: yyDollar[14].statement}, SubStatementPositionStart: yyDollar[13].int, SubStatementPositionEnd: yyDollar[15].int - 1} + yyVAL.val = EventName{} } +<<<<<<< Updated upstream case 1041: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5513 +======= + case 1042: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5432 +>>>>>>> Stashed changes { - yyVAL.eventName = EventName{} + yyVAL.val = yyDollar[3].val.(EventName) } case 1042: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5517 +======= +//line sql3.y:5438 +>>>>>>> Stashed changes { - yyVAL.eventName = yyDollar[3].eventName + yyVAL.val = yyDollar[3].val.(*DDL) } case 1043: yyDollar = yyS[yypt-3 : yypt+1] @@ -18697,38 +20262,73 @@ yydefault: } case 1044: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5527 +//line sql3.y:5442 { +<<<<<<< Updated upstream yyVAL.statement = &RenameUser{Accounts: yyDollar[3].accountRenames} } case 1045: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5533 +======= + yyVAL.val = &RenameUser{Accounts: yyDollar[3].val.([]AccountRename)} + } + case 1045: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5448 + { + yyVAL.val = &DDL{Action: RenameStr, FromTables: TableNames{yyDollar[1].val.(TableName)}, ToTables: TableNames{yyDollar[3].val.(TableName)}} + } + case 1046: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5452 +>>>>>>> Stashed changes { - yyVAL.ddl = &DDL{Action: RenameStr, FromTables: TableNames{yyDollar[1].tableName}, ToTables: TableNames{yyDollar[3].tableName}} + yyVAL.val = yyDollar[1].val.(*DDL) + yyVAL.val.(*DDL).FromTables = append(yyVAL.val.(*DDL).FromTables, yyDollar[3].val.(TableName)) + yyVAL.val.(*DDL).ToTables = append(yyVAL.val.(*DDL).ToTables, yyDollar[5].val.(TableName)) } +<<<<<<< Updated upstream case 1046: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5537 +======= + case 1047: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5460 +>>>>>>> Stashed changes { - yyVAL.ddl = yyDollar[1].ddl - yyVAL.ddl.FromTables = append(yyVAL.ddl.FromTables, yyDollar[3].tableName) - yyVAL.ddl.ToTables = append(yyVAL.ddl.ToTables, yyDollar[5].tableName) + yyVAL.val = []AccountRename{{From: yyDollar[1].val.(AccountName), To: yyDollar[3].val.(AccountName)}} } +<<<<<<< Updated upstream case 1047: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5545 +======= + case 1048: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5464 +>>>>>>> Stashed changes { - yyVAL.accountRenames = []AccountRename{{From: yyDollar[1].accountName, To: yyDollar[3].accountName}} + yyVAL.val = append(yyDollar[1].val.([]AccountRename), AccountRename{From: yyDollar[3].val.(AccountName), To: yyDollar[5].val.(AccountName)}) } case 1048: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5549 +======= +//line sql3.y:5470 +>>>>>>> Stashed changes { - yyVAL.accountRenames = append(yyDollar[1].accountRenames, AccountRename{From: yyDollar[3].accountName, To: yyDollar[5].accountName}) + var exists bool + if yyDollar[3].val.(byte) != 0 { + exists = true + } + yyVAL.val = &DDL{Action: DropStr, FromTables: yyDollar[4].val.(TableNames), IfExists: exists} } case 1049: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5555 { var exists bool @@ -18740,81 +20340,123 @@ yydefault: case 1050: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5563 +======= +//line sql3.y:5478 +>>>>>>> Stashed changes { // For consistency, we always use a AlterTable for ALTER TABLE equivalent statements - ddl := &DDL{Action: AlterStr, Table: yyDollar[5].tableName, IndexSpec: &IndexSpec{Action: DropStr, ToName: yyDollar[3].colIdent}} - yyVAL.statement = &AlterTable{Table: yyDollar[5].tableName, Statements: []*DDL{ddl}} + ddl := &DDL{Action: AlterStr, Table: yyDollar[5].val.(TableName), IndexSpec: &IndexSpec{Action: DropStr, ToName: yyDollar[3].val.(ColIdent)}} + yyVAL.val = &AlterTable{Table: yyDollar[5].val.(TableName), Statements: []*DDL{ddl}} + } + case 1051: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5484 + { + var exists bool + if yyDollar[3].val.(byte) != 0 { + exists = true + } + yyVAL.val = &DDL{Action: DropStr, FromViews: yyDollar[4].val.(TableNames), IfExists: exists} } case 1051: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5569 +======= +//line sql3.y:5492 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DDL{Action: DropStr, FromViews: yyDollar[4].tableNames, IfExists: exists} + yyVAL.val = &DBDDL{Action: DropStr, SchemaOrDatabase: "database", DBName: string(yyDollar[4].bytes), IfExists: exists} } case 1052: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5577 +======= +//line sql3.y:5500 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DBDDL{Action: DropStr, SchemaOrDatabase: "database", DBName: string(yyDollar[4].bytes), IfExists: exists} + yyVAL.val = &DBDDL{Action: DropStr, SchemaOrDatabase: "schema", DBName: string(yyDollar[4].bytes), IfExists: exists} } case 1053: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5585 +======= +//line sql3.y:5508 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DBDDL{Action: DropStr, SchemaOrDatabase: "schema", DBName: string(yyDollar[4].bytes), IfExists: exists} + yyVAL.val = &DDL{Action: DropStr, TriggerSpec: &TriggerSpec{TrigName: yyDollar[4].val.(TriggerName)}, IfExists: exists} } case 1054: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5593 +======= +//line sql3.y:5516 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DDL{Action: DropStr, TriggerSpec: &TriggerSpec{TrigName: yyDollar[4].triggerName}, IfExists: exists} + yyVAL.val = &DDL{Action: DropStr, ProcedureSpec: &ProcedureSpec{ProcName: yyDollar[4].val.(ProcedureName)}, IfExists: exists} } case 1055: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5601 +======= +//line sql3.y:5524 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DDL{Action: DropStr, ProcedureSpec: &ProcedureSpec{ProcName: yyDollar[4].procedureName}, IfExists: exists} + yyVAL.val = &DropUser{IfExists: exists, AccountNames: yyDollar[4].val.([]AccountName)} } case 1056: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5609 +======= +//line sql3.y:5532 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DropUser{IfExists: exists, AccountNames: yyDollar[4].accountNames} + yyVAL.val = &DropRole{IfExists: exists, Roles: yyDollar[4].val.([]AccountName)} } case 1057: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5617 +======= +//line sql3.y:5540 +>>>>>>> Stashed changes { var exists bool - if yyDollar[3].byt != 0 { + if yyDollar[3].val.(byte) != 0 { exists = true } - yyVAL.statement = &DropRole{IfExists: exists, Roles: yyDollar[4].accountNames} + yyVAL.val = &DDL{Action: DropStr, EventSpec: &EventSpec{EventName: yyDollar[4].val.(EventName)}, IfExists: exists} } +<<<<<<< Updated upstream case 1058: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5625 @@ -18828,45 +20470,89 @@ yydefault: case 1059: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5634 +======= + case 1059: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5549 +>>>>>>> Stashed changes { } case 1060: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5638 { yyVAL.ReferenceAction = Restrict +======= +//line sql3.y:5553 + { + yyVAL.val = Restrict +>>>>>>> Stashed changes } case 1061: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5642 +//line sql3.y:5557 { +<<<<<<< Updated upstream yyVAL.ReferenceAction = Cascade } case 1062: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5648 +======= + yyVAL.val = Cascade + } + case 1062: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5563 + { + yyVAL.val = &DDL{Action: TruncateStr, Table: yyDollar[3].val.(TableName)} + } + case 1063: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5567 +>>>>>>> Stashed changes { - yyVAL.statement = &DDL{Action: TruncateStr, Table: yyDollar[3].tableName} + yyVAL.val = &DDL{Action: TruncateStr, Table: yyDollar[2].val.(TableName)} } +<<<<<<< Updated upstream case 1063: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5652 +======= + case 1064: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5573 +>>>>>>> Stashed changes { - yyVAL.statement = &DDL{Action: TruncateStr, Table: yyDollar[2].tableName} + yyVAL.val = yyDollar[3].val.(Statement) } +<<<<<<< Updated upstream case 1064: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5658 +======= + case 1065: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:5579 +>>>>>>> Stashed changes { - yyVAL.statement = yyDollar[3].statement + yyVAL.val = &Analyze{Tables: []TableName{yyDollar[1].val.(TableName)}, Action: UpdateStr, Columns: yyDollar[5].val.(Columns), Using: yyDollar[8].val.(Expr)} } +<<<<<<< Updated upstream case 1065: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:5664 +======= + case 1066: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5583 +>>>>>>> Stashed changes { - yyVAL.statement = &Analyze{Tables: []TableName{yyDollar[1].tableName}, Action: UpdateStr, Columns: yyDollar[5].columns, Using: yyDollar[8].expr} + yyVAL.val = &Analyze{Tables: []TableName{yyDollar[1].val.(TableName)}, Action: DropStr, Columns: yyDollar[5].val.(Columns)} } +<<<<<<< Updated upstream case 1066: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5668 @@ -18876,8 +20562,19 @@ yydefault: case 1067: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:5672 +======= + case 1067: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5587 +>>>>>>> Stashed changes + { + yyVAL.val = &Analyze{Tables: yyDollar[1].val.(TableNames)} + } + case 1072: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5599 { - yyVAL.statement = &Analyze{Tables: yyDollar[1].tableNames} + yyVAL.val = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].bytes)} } case 1072: yyDollar = yyS[yypt-4 : yypt+1] @@ -18887,33 +20584,53 @@ yydefault: } case 1073: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5688 +//line sql3.y:5603 { - yyVAL.statement = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].bytes)} + yyVAL.val = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].bytes)} } case 1074: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5692 +//line sql3.y:5607 { +<<<<<<< Updated upstream yyVAL.statement = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].str)} +======= + yyVAL.val = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].val.(string))} +>>>>>>> Stashed changes } case 1075: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5696 +//line sql3.y:5611 { - yyVAL.statement = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].str)} + yyVAL.val = &Prepare{Name: string(yyDollar[2].bytes), Expr: string(yyDollar[4].val.(string))} } case 1076: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5702 +======= +//line sql3.y:5617 + { + yyVAL.val = []string{yyDollar[1].val.(string)} + } + case 1077: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5621 +>>>>>>> Stashed changes { - yyVAL.strs = []string{yyDollar[1].str} + yyVAL.val = append(yyDollar[1].val.([]string), yyDollar[3].val.(string)) } +<<<<<<< Updated upstream case 1077: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5706 +======= + case 1078: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5628 +>>>>>>> Stashed changes { - yyVAL.strs = append(yyDollar[1].strs, yyDollar[3].str) + yyVAL.val = string(yyDollar[1].bytes) } case 1078: yyDollar = yyS[yypt-1 : yypt+1] @@ -18923,75 +20640,115 @@ yydefault: } case 1079: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5717 +//line sql3.y:5632 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 1080: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5723 { yyVAL.statement = &Execute{Name: string(yyDollar[2].bytes)} +======= +//line sql3.y:5638 + { + yyVAL.val = &Execute{Name: string(yyDollar[2].bytes)} +>>>>>>> Stashed changes } case 1081: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5727 +//line sql3.y:5642 { - yyVAL.statement = &Execute{Name: string(yyDollar[2].bytes)} + yyVAL.val = &Execute{Name: string(yyDollar[2].bytes)} } case 1082: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5731 { yyVAL.statement = &Execute{Name: string(yyDollar[2].bytes), VarList: yyDollar[4].strs} +======= +//line sql3.y:5646 + { + yyVAL.val = &Execute{Name: string(yyDollar[2].bytes), VarList: yyDollar[4].val.([]string)} +>>>>>>> Stashed changes } case 1083: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5735 +//line sql3.y:5650 { - yyVAL.statement = &Execute{Name: string(yyDollar[2].bytes), VarList: yyDollar[4].strs} + yyVAL.val = &Execute{Name: string(yyDollar[2].bytes), VarList: yyDollar[4].val.([]string)} } case 1084: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5741 { yyVAL.statement = &Deallocate{Name: string(yyDollar[3].bytes)} +======= +//line sql3.y:5656 + { + yyVAL.val = &Deallocate{Name: string(yyDollar[3].bytes)} +>>>>>>> Stashed changes } case 1085: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5745 +//line sql3.y:5660 { - yyVAL.statement = &Deallocate{Name: string(yyDollar[3].bytes)} + yyVAL.val = &Deallocate{Name: string(yyDollar[3].bytes)} } case 1086: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5749 +//line sql3.y:5664 { - yyVAL.statement = &Deallocate{Name: string(yyDollar[3].bytes)} + yyVAL.val = &Deallocate{Name: string(yyDollar[3].bytes)} } case 1087: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5753 +//line sql3.y:5668 { - yyVAL.statement = &Deallocate{Name: string(yyDollar[3].bytes)} + yyVAL.val = &Deallocate{Name: string(yyDollar[3].bytes)} } case 1088: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5759 +======= +//line sql3.y:5675 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} + } + case 1089: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5680 +>>>>>>> Stashed changes + { + yyVAL.val = &Show{Type: CharsetStr, Filter: yyDollar[4].val.(*ShowFilter)} } +<<<<<<< Updated upstream case 1089: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5764 +======= + case 1090: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5684 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: CharsetStr, Filter: yyDollar[4].showFilter} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), Filter: yyDollar[3].val.(*ShowFilter)} } +<<<<<<< Updated upstream case 1090: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5768 +======= + case 1091: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5688 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), Filter: yyDollar[3].showFilter} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), IfNotExists: yyDollar[4].val.(byte) == 1, Database: string(yyDollar[5].bytes)} } case 1091: yyDollar = yyS[yypt-5 : yypt+1] @@ -19001,16 +20758,27 @@ yydefault: } case 1092: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:5776 +//line sql3.y:5692 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), IfNotExists: yyDollar[4].byt == 1, Database: string(yyDollar[5].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), IfNotExists: yyDollar[4].val.(byte) == 1, Database: string(yyDollar[5].bytes)} } case 1093: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:5780 +//line sql3.y:5696 { +<<<<<<< Updated upstream showTablesOpt := &ShowTablesOpt{AsOf: yyDollar[5].expr} yyVAL.statement = &Show{Type: CreateTableStr, Table: yyDollar[4].tableName, ShowTablesOpt: showTablesOpt} +======= + showTablesOpt := &ShowTablesOpt{AsOf: yyDollar[5].val.(Expr)} + yyVAL.val = &Show{Type: CreateTableStr, Table: yyDollar[4].val.(TableName), ShowTablesOpt: showTablesOpt} + } + case 1094: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5701 + { + yyVAL.val = &Show{Type: CreateProcedureStr, Table: yyDollar[4].val.(TableName)} +>>>>>>> Stashed changes } case 1094: yyDollar = yyS[yypt-4 : yypt+1] @@ -19020,27 +20788,49 @@ yydefault: } case 1095: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5789 +//line sql3.y:5705 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Type: CreateTriggerStr, Table: yyDollar[4].tableName} +======= + yyVAL.val = &Show{Type: CreateTriggerStr, Table: yyDollar[4].val.(TableName)} +>>>>>>> Stashed changes } case 1096: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5793 +//line sql3.y:5709 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Table: yyDollar[4].tableName} +======= + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Table: yyDollar[4].val.(TableName)} +>>>>>>> Stashed changes } case 1097: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5797 +//line sql3.y:5713 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Type: CreateEventStr, Table: yyDollar[4].tableName} } case 1098: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5801 +======= + yyVAL.val = &Show{Type: CreateEventStr, Table: yyDollar[4].val.(TableName)} + } + case 1098: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5717 + { + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), Filter: yyDollar[3].val.(*ShowFilter)} + } + case 1099: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5721 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), Filter: yyDollar[3].showFilter} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes)} } case 1099: yyDollar = yyS[yypt-2 : yypt+1] @@ -19050,33 +20840,61 @@ yydefault: } case 1100: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5809 +//line sql3.y:5725 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes)} } case 1101: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5813 +======= +//line sql3.y:5729 + { + yyVAL.val = &Show{Type: IndexStr, Table: yyDollar[4].val.(TableName), Database: yyDollar[5].val.(string), ShowIndexFilterOpt: yyDollar[6].val.(Expr)} + } + case 1102: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5733 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: IndexStr, Table: yyDollar[4].tableName, Database: yyDollar[5].str, ShowIndexFilterOpt: yyDollar[6].expr} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes)} } +<<<<<<< Updated upstream case 1102: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5817 +======= + case 1103: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5737 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Filter: yyDollar[4].val.(*ShowFilter)} } +<<<<<<< Updated upstream case 1103: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5821 +======= + case 1104: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5741 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Filter: yyDollar[4].showFilter} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1104: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5825 +======= + case 1105: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5745 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Filter: yyDollar[4].val.(*ShowFilter)} } case 1105: yyDollar = yyS[yypt-4 : yypt+1] @@ -19086,35 +20904,67 @@ yydefault: } case 1106: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5833 +//line sql3.y:5749 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Scope: yyDollar[2].str, Type: string(yyDollar[3].bytes), Filter: yyDollar[4].showFilter} } case 1107: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5837 +======= + yyVAL.val = &Show{Scope: yyDollar[2].val.(string), Type: string(yyDollar[3].bytes), Filter: yyDollar[4].val.(*ShowFilter)} + } + case 1107: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5753 + { + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Database: yyDollar[4].val.(string), Filter: yyDollar[5].val.(*ShowFilter)} + } + case 1108: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:5757 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes), Database: yyDollar[4].str, Filter: yyDollar[5].showFilter} + showTablesOpt := &ShowTablesOpt{DbName: yyDollar[6].val.(string), AsOf: yyDollar[7].val.(Expr), Filter: yyDollar[8].val.(*ShowFilter)} + yyVAL.val = &Show{Type: string(yyDollar[3].val.(string)), ShowTablesOpt: showTablesOpt, Table: yyDollar[5].val.(TableName), Full: yyDollar[2].val.(bool)} } +<<<<<<< Updated upstream case 1108: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:5841 +======= + case 1109: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:5762 +>>>>>>> Stashed changes { - showTablesOpt := &ShowTablesOpt{DbName: yyDollar[6].str, AsOf: yyDollar[7].expr, Filter: yyDollar[8].showFilter} - yyVAL.statement = &Show{Type: string(yyDollar[3].str), ShowTablesOpt: showTablesOpt, Table: yyDollar[5].tableName, Full: yyDollar[2].boolean} + showTablesOpt := &ShowTablesOpt{DbName: yyDollar[4].val.(string), Filter: yyDollar[6].val.(*ShowFilter), AsOf: yyDollar[5].val.(Expr)} + yyVAL.val = &Show{Type: string(yyDollar[3].bytes), ShowTablesOpt: showTablesOpt, Full: yyDollar[2].val.(bool)} } +<<<<<<< Updated upstream case 1109: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:5846 +======= + case 1110: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5767 +>>>>>>> Stashed changes { - showTablesOpt := &ShowTablesOpt{DbName: yyDollar[4].str, Filter: yyDollar[6].showFilter, AsOf: yyDollar[5].expr} - yyVAL.statement = &Show{Type: string(yyDollar[3].bytes), ShowTablesOpt: showTablesOpt, Full: yyDollar[2].boolean} + yyVAL.val = &Show{Type: string(yyDollar[3].bytes), Full: yyDollar[2].val.(bool)} } +<<<<<<< Updated upstream case 1110: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5851 +======= + case 1111: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5771 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[3].bytes), Full: yyDollar[2].boolean} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), ShowTablesOpt: &ShowTablesOpt{DbName: yyDollar[3].val.(string), Filter: yyDollar[4].val.(*ShowFilter)}} } case 1111: yyDollar = yyS[yypt-4 : yypt+1] @@ -19124,61 +20974,117 @@ yydefault: } case 1112: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:5859 +//line sql3.y:5775 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Scope: yyDollar[2].str, Type: string(yyDollar[3].bytes), Filter: yyDollar[4].showFilter} } case 1113: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5863 +======= + yyVAL.val = &Show{Scope: yyDollar[2].val.(string), Type: string(yyDollar[3].bytes), Filter: yyDollar[4].val.(*ShowFilter)} + } + case 1113: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5779 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes)} } case 1114: yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5783 +>>>>>>> Stashed changes + { + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), ShowCollationFilterOpt: yyDollar[4].val.(Expr)} + } +<<<<<<< Updated upstream + case 1114: + yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5867 +======= + case 1115: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5787 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), ShowCollationFilterOpt: yyDollar[4].expr} + cmp := yyDollar[3].val.(Expr).(*ComparisonExpr) + cmp.Left = &ColName{Name: NewColIdent("collation")} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), ShowCollationFilterOpt: cmp} } +<<<<<<< Updated upstream case 1115: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5871 +======= + case 1116: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5793 +>>>>>>> Stashed changes { - cmp := yyDollar[3].expr.(*ComparisonExpr) - cmp.Left = &ColName{Name: NewColIdent("collation")} - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), ShowCollationFilterOpt: cmp} + yyVAL.val = &ShowGrants{} } +<<<<<<< Updated upstream case 1116: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5877 +======= + case 1117: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5797 +>>>>>>> Stashed changes { - yyVAL.statement = &ShowGrants{} + an := yyDollar[4].val.(AccountName) + yyVAL.val = &ShowGrants{For: &an} } +<<<<<<< Updated upstream case 1117: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5881 +======= + case 1118: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:5802 +>>>>>>> Stashed changes { - an := yyDollar[4].accountName - yyVAL.statement = &ShowGrants{For: &an} + yyVAL.val = &ShowGrants{CurrentUser: true} } +<<<<<<< Updated upstream case 1118: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:5886 +======= + case 1119: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:5806 +>>>>>>> Stashed changes { - yyVAL.statement = &ShowGrants{CurrentUser: true} + an := yyDollar[4].val.(AccountName) + yyVAL.val = &ShowGrants{For: &an, Using: yyDollar[6].val.([]AccountName)} } +<<<<<<< Updated upstream case 1119: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:5890 +======= + case 1120: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5811 +>>>>>>> Stashed changes { - an := yyDollar[4].accountName - yyVAL.statement = &ShowGrants{For: &an, Using: yyDollar[6].accountNames} + yyVAL.val = &ShowPrivileges{} } +<<<<<<< Updated upstream case 1120: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5895 +======= + case 1121: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:5815 +>>>>>>> Stashed changes { - yyVAL.statement = &ShowPrivileges{} + yyVAL.val = &Show{Type: string(yyDollar[6].bytes), CountStar: true} } case 1121: yyDollar = yyS[yypt-6 : yypt+1] @@ -19188,39 +21094,67 @@ yydefault: } case 1122: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:5903 +//line sql3.y:5819 { - yyVAL.statement = &Show{Type: string(yyDollar[6].bytes), CountStar: true} + yyVAL.val = &Show{Type: string(yyDollar[6].bytes), CountStar: true} } case 1123: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5907 { yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), Limit: yyDollar[3].limit} +======= +//line sql3.y:5823 + { + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), Limit: yyDollar[3].val.(*Limit)} +>>>>>>> Stashed changes } case 1124: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5911 +//line sql3.y:5827 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), Limit: yyDollar[3].limit} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), Limit: yyDollar[3].val.(*Limit)} } case 1125: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5915 +======= +//line sql3.y:5831 { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes), ShowTablesOpt: &ShowTablesOpt{DbName: yyDollar[3].str, Filter: yyDollar[4].showFilter}} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes), ShowTablesOpt: &ShowTablesOpt{DbName: yyDollar[3].val.(string), Filter: yyDollar[4].val.(*ShowFilter)}} } case 1126: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5835 +>>>>>>> Stashed changes + { + yyVAL.val = &Show{Type: string(yyDollar[2].bytes)} + } +<<<<<<< Updated upstream + case 1126: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5919 +======= + case 1127: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5839 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes)} + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} } +<<<<<<< Updated upstream case 1127: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:5923 +======= + case 1128: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5843 +>>>>>>> Stashed changes { - yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes) + " " + string(yyDollar[4].bytes)} + yyVAL.val = &Show{Type: "BINARY LOG STATUS"} } case 1128: yyDollar = yyS[yypt-3 : yypt+1] @@ -19230,27 +21164,51 @@ yydefault: } case 1129: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:5931 +//line sql3.y:5847 { +<<<<<<< Updated upstream yyVAL.statement = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} } case 1130: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5937 +======= + yyVAL.val = &Show{Type: string(yyDollar[2].bytes) + " " + string(yyDollar[3].bytes)} + } + case 1130: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5853 + { + yyVAL.val = &ComparisonExpr{Operator: LikeStr, Right: yyDollar[2].val.(Expr), Escape: yyDollar[3].val.(Expr)} + } + case 1131: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5859 +>>>>>>> Stashed changes { - yyVAL.expr = &ComparisonExpr{Operator: LikeStr, Right: yyDollar[2].expr, Escape: yyDollar[3].expr} + yyVAL.val = false } +<<<<<<< Updated upstream case 1131: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5943 +======= + case 1132: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5863 +>>>>>>> Stashed changes { - yyVAL.boolean = false + yyVAL.val = true } case 1132: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5947 +======= +//line sql3.y:5869 +>>>>>>> Stashed changes { - yyVAL.boolean = true + yyVAL.val = string(yyDollar[1].bytes) } case 1133: yyDollar = yyS[yypt-1 : yypt+1] @@ -19260,15 +21218,25 @@ yydefault: } case 1134: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:5957 +//line sql3.y:5873 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 1135: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5963 +======= +//line sql3.y:5879 { - yyVAL.str = "" + yyVAL.val = "" + } + case 1136: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5883 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[2].val.(TableIdent).v } case 1136: yyDollar = yyS[yypt-2 : yypt+1] @@ -19278,39 +21246,73 @@ yydefault: } case 1137: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:5971 +//line sql3.y:5887 { - yyVAL.str = yyDollar[2].tableIdent.v + yyVAL.val = yyDollar[2].val.(TableIdent).v } case 1138: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:5977 +======= +//line sql3.y:5893 + { + yyVAL.val = &ShowFilter{} + } + case 1139: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5897 +>>>>>>> Stashed changes { - yyVAL.showFilter = nil + yyVAL.val = &ShowFilter{Like: string(yyDollar[2].bytes)} } +<<<<<<< Updated upstream case 1139: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5981 +======= + case 1140: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:5901 +>>>>>>> Stashed changes { - yyVAL.showFilter = &ShowFilter{Like: string(yyDollar[2].bytes)} + yyVAL.val = &ShowFilter{Like: string(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1140: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:5985 +======= + case 1141: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5905 +>>>>>>> Stashed changes { - yyVAL.showFilter = &ShowFilter{Like: string(yyDollar[3].bytes)} + yyVAL.val = &ShowFilter{Filter: yyDollar[2].val.(Expr)} } +<<<<<<< Updated upstream case 1141: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:5989 +======= + case 1142: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5911 +>>>>>>> Stashed changes { - yyVAL.showFilter = &ShowFilter{Filter: yyDollar[2].expr} + yyVAL.val = "" } +<<<<<<< Updated upstream case 1142: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:5995 +======= + case 1143: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5915 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = SessionStr } case 1143: yyDollar = yyS[yypt-1 : yypt+1] @@ -19320,28 +21322,55 @@ yydefault: } case 1144: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6003 +//line sql3.y:5919 { +<<<<<<< Updated upstream yyVAL.str = GlobalStr } case 1145: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6009 +======= + yyVAL.val = GlobalStr + } + case 1145: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5925 + { + yyVAL.val = &Use{DBName: yyDollar[2].val.(TableIdent)} + } + case 1146: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5929 +>>>>>>> Stashed changes { - yyVAL.statement = &Use{DBName: yyDollar[2].tableIdent} + yyVAL.val = &Use{DBName: TableIdent{v: yyDollar[2].val.(TableIdent).v + "/" + yyDollar[4].val.(TableIdent).v}} } +<<<<<<< Updated upstream case 1146: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6013 +======= + case 1147: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5933 +>>>>>>> Stashed changes { - yyVAL.statement = &Use{DBName: TableIdent{v: yyDollar[2].tableIdent.v + "/" + yyDollar[4].tableIdent.v}} + yyVAL.val = &Use{DBName: TableIdent{v: ""}} } +<<<<<<< Updated upstream case 1147: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6017 +======= + case 1148: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5938 +>>>>>>> Stashed changes { - yyVAL.statement = &Use{DBName: TableIdent{v: ""}} + yyVAL.bytes = []byte(nil) } +<<<<<<< Updated upstream case 1148: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6022 @@ -19351,26 +21380,53 @@ yydefault: case 1149: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6026 +======= + case 1149: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5942 +>>>>>>> Stashed changes { yyVAL.bytes = yyDollar[1].bytes } case 1150: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6032 +======= +//line sql3.y:5948 +>>>>>>> Stashed changes { - yyVAL.statement = &Begin{} + yyVAL.val = &Begin{} } case 1151: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6036 +//line sql3.y:5952 { - yyVAL.statement = yyDollar[1].statement + yyVAL.val = yyDollar[1].val.(Statement) } - case 1152: - yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream + case 1151: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql.y:6036 +======= + case 1152: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:5958 +>>>>>>> Stashed changes + { + yyVAL.val = &Begin{} + } +<<<<<<< Updated upstream + case 1152: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6042 +======= + case 1153: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5962 +>>>>>>> Stashed changes { - yyVAL.statement = &Begin{} + yyVAL.val = &Begin{TransactionCharacteristic: TxReadWrite} } case 1153: yyDollar = yyS[yypt-4 : yypt+1] @@ -19380,8 +21436,9 @@ yydefault: } case 1154: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6050 +//line sql3.y:5966 { +<<<<<<< Updated upstream yyVAL.statement = &Begin{TransactionCharacteristic: TxReadOnly} } case 1155: @@ -19393,56 +21450,114 @@ yydefault: case 1156: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6059 +======= + yyVAL.val = &Begin{TransactionCharacteristic: TxReadOnly} + } + case 1155: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:5971 { - yyVAL.bytes = nil + yyVAL.bytes = []byte(nil) + } + case 1156: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:5975 +>>>>>>> Stashed changes + { + yyVAL.bytes = []byte(nil) } case 1157: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6064 +======= +//line sql3.y:5980 +>>>>>>> Stashed changes { - yyVAL.bytes = nil + yyVAL.bytes = []byte(nil) } case 1158: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6068 +======= +//line sql3.y:5984 +>>>>>>> Stashed changes { - yyVAL.bytes = nil + yyVAL.bytes = []byte(nil) } case 1159: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6073 +======= +//line sql3.y:5989 +>>>>>>> Stashed changes { - yyVAL.bytes = nil + yyVAL.bytes = []byte(nil) } case 1160: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6077 +======= +//line sql3.y:5993 +>>>>>>> Stashed changes { - yyVAL.bytes = nil + yyVAL.bytes = []byte(nil) } case 1161: +<<<<<<< Updated upstream yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6083 +======= + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:5999 { - yyVAL.statement = &Commit{} + yyVAL.val = &Commit{} } case 1162: yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6005 +>>>>>>> Stashed changes + { + yyVAL.val = &Rollback{} + } +<<<<<<< Updated upstream + case 1162: + yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6089 +======= + case 1163: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6011 +>>>>>>> Stashed changes { - yyVAL.statement = &Rollback{} + yyVAL.val = &Savepoint{Identifier: string(yyDollar[2].bytes)} } +<<<<<<< Updated upstream case 1163: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6095 +======= + case 1164: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6017 +>>>>>>> Stashed changes { - yyVAL.statement = &Savepoint{Identifier: string(yyDollar[2].bytes)} + yyVAL.val = &RollbackSavepoint{Identifier: string(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1164: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6101 +======= + case 1165: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6021 +>>>>>>> Stashed changes { - yyVAL.statement = &RollbackSavepoint{Identifier: string(yyDollar[3].bytes)} + yyVAL.val = &RollbackSavepoint{Identifier: string(yyDollar[4].bytes)} } case 1165: yyDollar = yyS[yypt-4 : yypt+1] @@ -19452,34 +21567,61 @@ yydefault: } case 1166: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6109 +//line sql3.y:6025 { - yyVAL.statement = &RollbackSavepoint{Identifier: string(yyDollar[4].bytes)} + yyVAL.val = &RollbackSavepoint{Identifier: string(yyDollar[4].bytes)} } case 1167: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6113 +======= +//line sql3.y:6029 + { + yyVAL.val = &RollbackSavepoint{Identifier: string(yyDollar[5].bytes)} + } + case 1168: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6035 +>>>>>>> Stashed changes { - yyVAL.statement = &RollbackSavepoint{Identifier: string(yyDollar[5].bytes)} + yyVAL.val = &ReleaseSavepoint{Identifier: string(yyDollar[3].bytes)} } case 1168: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6119 +======= +//line sql3.y:6041 +>>>>>>> Stashed changes { - yyVAL.statement = &ReleaseSavepoint{Identifier: string(yyDollar[3].bytes)} + yyVAL.val = &Explain{ExplainFormat: yyDollar[2].val.(string), Statement: yyDollar[3].val.(Statement)} } +<<<<<<< Updated upstream case 1169: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6125 +======= + case 1170: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6045 +>>>>>>> Stashed changes { - yyVAL.statement = &Explain{ExplainFormat: yyDollar[2].str, Statement: yyDollar[3].statement} + yyVAL.val = &Explain{ExplainFormat: yyDollar[3].val.(string), Statement: yyDollar[4].val.(Statement)} } +<<<<<<< Updated upstream case 1170: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6129 +======= + case 1171: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6049 +>>>>>>> Stashed changes { - yyVAL.statement = &Explain{ExplainFormat: yyDollar[3].str, Statement: yyDollar[4].statement} + yyVAL.val = &Explain{Analyze: true, ExplainFormat: TreeStr, Statement: yyDollar[3].val.(SelectStatement)} } +<<<<<<< Updated upstream case 1171: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6133 @@ -19489,11 +21631,23 @@ yydefault: case 1172: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6139 +======= + case 1172: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6055 +>>>>>>> Stashed changes { - yyVAL.statement = yyDollar[1].selStmt + yyVAL.val = yyDollar[1].val.(SelectStatement) } case 1176: yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6063 + { + yyVAL.val = "" + } +<<<<<<< Updated upstream + case 1176: + yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6147 { yyVAL.str = "" @@ -19501,11 +21655,24 @@ yydefault: case 1177: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6151 +======= + case 1177: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6067 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[3].bytes) + yyVAL.val = string(yyDollar[3].bytes) } case 1181: yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6079 + { + showTablesOpt := &ShowTablesOpt{AsOf: yyDollar[3].val.(Expr)} + yyVAL.val = &Show{Type: "columns", Table: yyDollar[2].val.(TableName), ShowTablesOpt: showTablesOpt} + } +<<<<<<< Updated upstream + case 1181: + yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6163 { showTablesOpt := &ShowTablesOpt{AsOf: yyDollar[3].expr} @@ -19514,33 +21681,64 @@ yydefault: case 1182: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6169 +======= + case 1182: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6085 +>>>>>>> Stashed changes { setAllowComments(yylex, true) } case 1183: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6173 +======= +//line sql3.y:6089 +>>>>>>> Stashed changes { - yyVAL.bytes2 = yyDollar[2].bytes2 + yyVAL.val = [][]byte(nil) setAllowComments(yylex, false) } case 1184: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6179 +======= +//line sql3.y:6095 +>>>>>>> Stashed changes + { + yyVAL.val = [][]byte(nil) + } + case 1185: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6099 { - yyVAL.bytes2 = nil + yyVAL.val = append(yyDollar[1].val.([][]byte), yyDollar[2].bytes) } +<<<<<<< Updated upstream case 1185: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6183 +======= + case 1186: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6105 +>>>>>>> Stashed changes { - yyVAL.bytes2 = append(yyDollar[1].bytes2, yyDollar[2].bytes) + yyVAL.val = UnionStr } +<<<<<<< Updated upstream case 1186: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6189 +======= + case 1187: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6109 +>>>>>>> Stashed changes { - yyVAL.str = UnionStr + yyVAL.val = UnionAllStr } case 1187: yyDollar = yyS[yypt-2 : yypt+1] @@ -19550,15 +21748,29 @@ yydefault: } case 1188: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6197 +//line sql3.y:6113 { +<<<<<<< Updated upstream yyVAL.str = UnionDistinctStr } case 1189: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6203 +======= + yyVAL.val = UnionDistinctStr + } + case 1189: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6119 { - yyVAL.str = IntersectStr + yyVAL.val = IntersectStr + } + case 1190: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6123 +>>>>>>> Stashed changes + { + yyVAL.val = IntersectAllStr } case 1190: yyDollar = yyS[yypt-2 : yypt+1] @@ -19568,15 +21780,29 @@ yydefault: } case 1191: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6211 +//line sql3.y:6127 { +<<<<<<< Updated upstream yyVAL.str = IntersectDistinctStr } case 1192: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6217 +======= + yyVAL.val = IntersectDistinctStr + } + case 1192: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6133 + { + yyVAL.val = ExceptStr + } + case 1193: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6137 +>>>>>>> Stashed changes { - yyVAL.str = ExceptStr + yyVAL.val = ExceptAllStr } case 1193: yyDollar = yyS[yypt-2 : yypt+1] @@ -19586,62 +21812,103 @@ yydefault: } case 1194: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6225 +//line sql3.y:6141 { +<<<<<<< Updated upstream yyVAL.str = ExceptDistinctStr } case 1195: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6230 +======= + yyVAL.val = ExceptDistinctStr + } + case 1195: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6146 { - yyVAL.queryOpts = QueryOpts{} + yyVAL.val = QueryOpts{} } case 1196: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6234 +//line sql3.y:6150 +>>>>>>> Stashed changes { opt := QueryOpts{All: true} - if err := yyDollar[1].queryOpts.merge(opt); err != nil { + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.queryOpts = yyDollar[1].queryOpts + yyVAL.val = yyDollar[1].val.(QueryOpts) + } + case 1196: + yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream +//line sql.y:6234 +======= +//line sql3.y:6160 +>>>>>>> Stashed changes + { + opt := QueryOpts{Distinct: true} + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { + yylex.Error(err.Error()) + return 1 + } + yyVAL.val = yyDollar[1].val.(QueryOpts) } case 1197: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6243 +======= +//line sql3.y:6170 +>>>>>>> Stashed changes { - opt := QueryOpts{Distinct: true} - if err := yyDollar[1].queryOpts.merge(opt); err != nil { + opt := QueryOpts{StraightJoinHint: true} + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.queryOpts = yyDollar[1].queryOpts + yyVAL.val = yyDollar[1].val.(QueryOpts) } case 1198: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6252 +======= +//line sql3.y:6180 +>>>>>>> Stashed changes { - opt := QueryOpts{StraightJoinHint: true} - if err := yyDollar[1].queryOpts.merge(opt); err != nil { + opt := QueryOpts{SQLCalcFoundRows: true} + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.queryOpts = yyDollar[1].queryOpts + yyVAL.val = yyDollar[1].val.(QueryOpts) } case 1199: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6261 +======= +//line sql3.y:6190 +>>>>>>> Stashed changes { - opt := QueryOpts{SQLCalcFoundRows: true} - if err := yyDollar[1].queryOpts.merge(opt); err != nil { + opt := QueryOpts{SQLCache: true} + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.queryOpts = yyDollar[1].queryOpts + yyVAL.val = yyDollar[1].val.(QueryOpts) } case 1200: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6270 { opt := QueryOpts{SQLCache: true} @@ -19654,19 +21921,35 @@ yydefault: case 1201: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6279 +======= +//line sql3.y:6200 +>>>>>>> Stashed changes { opt := QueryOpts{SQLNoCache: true} - if err := yyDollar[1].queryOpts.merge(opt); err != nil { + ct := yyDollar[1].val.(QueryOpts) + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } - yyVAL.queryOpts = yyDollar[1].queryOpts + yyVAL.val = yyDollar[1].val.(QueryOpts) + } + case 1202: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6211 + { + yyVAL.val = "" } +<<<<<<< Updated upstream case 1202: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6289 +======= + case 1203: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6215 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = AllStr } case 1203: yyDollar = yyS[yypt-1 : yypt+1] @@ -19676,29 +21959,49 @@ yydefault: } case 1204: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6297 +//line sql3.y:6219 { +<<<<<<< Updated upstream yyVAL.str = DistinctStr } case 1205: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6303 +======= + yyVAL.val = DistinctStr + } + case 1205: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6225 { - if ae, ok := yyDollar[2].selectExpr.(*AliasedExpr); ok { - ae.StartParsePos = yyDollar[1].int - ae.EndParsePos = yyDollar[3].int - 1 + if ae, ok := yyDollar[2].val.(SelectExpr).(*AliasedExpr); ok { + ae.StartParsePos = yyDollar[1].val.(int) + ae.EndParsePos = yyDollar[3].val.(int) - 1 } - yyVAL.selectExprs = SelectExprs{yyDollar[2].selectExpr} + yyVAL.val = SelectExprs{yyDollar[2].val.(SelectExpr)} } case 1206: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:6311 +//line sql3.y:6233 +>>>>>>> Stashed changes { - if ae, ok := yyDollar[4].selectExpr.(*AliasedExpr); ok { - ae.StartParsePos = yyDollar[3].int - ae.EndParsePos = yyDollar[5].int - 1 + if ae, ok := yyDollar[4].val.(SelectExpr).(*AliasedExpr); ok { + ae.StartParsePos = yyDollar[3].val.(int) + ae.EndParsePos = yyDollar[5].val.(int) - 1 } - yyVAL.selectExprs = append(yyVAL.selectExprs, yyDollar[4].selectExpr) + yyVAL.val = append(yyVAL.val.(SelectExprs), yyDollar[4].val.(SelectExpr)) + } +<<<<<<< Updated upstream + case 1206: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql.y:6311 +======= + case 1207: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6244 +>>>>>>> Stashed changes + { + yyVAL.val = &StarExpr{} } case 1207: yyDollar = yyS[yypt-1 : yypt+1] @@ -19708,45 +22011,89 @@ yydefault: } case 1208: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6326 +//line sql3.y:6248 { +<<<<<<< Updated upstream yyVAL.selectExpr = &AliasedExpr{Expr: yyDollar[1].expr} } case 1209: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6330 +======= + yyVAL.val = &AliasedExpr{Expr: yyDollar[1].val.(Expr)} + } + case 1209: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6252 { - yyVAL.selectExpr = &StarExpr{TableName: TableName{Name: yyDollar[1].tableIdent}} + yyVAL.val = &StarExpr{TableName: TableName{Name: yyDollar[1].val.(TableIdent)}} } case 1210: yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:6256 +>>>>>>> Stashed changes + { + yyVAL.val = &StarExpr{TableName: TableName{DbQualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(TableIdent)}} + } +<<<<<<< Updated upstream + case 1210: + yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:6334 +======= + case 1211: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6262 +>>>>>>> Stashed changes { - yyVAL.selectExpr = &StarExpr{TableName: TableName{DbQualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent}} + yyVAL.val = &StarExpr{} } +<<<<<<< Updated upstream case 1211: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6340 +======= + case 1212: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6266 +>>>>>>> Stashed changes { - yyVAL.selectExpr = &StarExpr{} + yyVAL.val = &AliasedExpr{Expr: yyDollar[1].val.(Expr), As: yyDollar[2].val.(ColIdent)} } +<<<<<<< Updated upstream case 1212: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6344 +======= + case 1213: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6270 +>>>>>>> Stashed changes { - yyVAL.selectExpr = &AliasedExpr{Expr: yyDollar[1].expr, As: yyDollar[2].colIdent} + yyVAL.val = &StarExpr{TableName: TableName{Name: yyDollar[1].val.(TableIdent)}} } +<<<<<<< Updated upstream case 1213: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6348 +======= + case 1214: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:6274 +>>>>>>> Stashed changes { - yyVAL.selectExpr = &StarExpr{TableName: TableName{Name: yyDollar[1].tableIdent}} + yyVAL.val = &StarExpr{TableName: TableName{DbQualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(TableIdent)}} } +<<<<<<< Updated upstream case 1214: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:6352 +======= + case 1215: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6280 +>>>>>>> Stashed changes { - yyVAL.selectExpr = &StarExpr{TableName: TableName{DbQualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent}} + yyVAL.val = &Over{NameRef: yyDollar[2].val.(ColIdent)} } case 1215: yyDollar = yyS[yypt-2 : yypt+1] @@ -19756,57 +22103,113 @@ yydefault: } case 1216: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6362 +//line sql3.y:6284 { +<<<<<<< Updated upstream yyVAL.over = (*Over)(yyDollar[2].windowDef) } case 1217: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:6368 +======= + yyVAL.val = (*Over)(yyDollar[2].val.(*WindowDef)) + } + case 1217: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:6290 + { + yyVAL.val = &WindowDef{NameRef: yyDollar[2].val.(ColIdent), PartitionBy: yyDollar[3].val.(Exprs), OrderBy: yyDollar[4].val.(OrderBy), Frame: yyDollar[5].val.(*Frame)} + } + case 1218: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6295 +>>>>>>> Stashed changes { - yyVAL.windowDef = &WindowDef{NameRef: yyDollar[2].colIdent, PartitionBy: yyDollar[3].exprs, OrderBy: yyDollar[4].orderBy, Frame: yyDollar[5].frame} + yyVAL.val = ColIdent{} } +<<<<<<< Updated upstream case 1218: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6373 +======= + case 1219: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6298 +>>>>>>> Stashed changes { - yyVAL.colIdent = ColIdent{} + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } +<<<<<<< Updated upstream case 1219: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6376 +======= + case 1220: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6303 +>>>>>>> Stashed changes { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = Exprs(nil) } +<<<<<<< Updated upstream case 1220: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6381 +======= + case 1221: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6307 +>>>>>>> Stashed changes { - yyVAL.exprs = nil + yyVAL.val = yyDollar[3].val.(Exprs) } +<<<<<<< Updated upstream case 1221: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6385 +======= + case 1222: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6312 +>>>>>>> Stashed changes { - yyVAL.exprs = yyDollar[3].exprs + yyVAL.val = &Over{} } +<<<<<<< Updated upstream case 1222: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6390 +======= + case 1223: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6316 +>>>>>>> Stashed changes { - yyVAL.over = nil + yyVAL.val = yyDollar[1].val.(*Over) } +<<<<<<< Updated upstream case 1223: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6394 +======= + case 1224: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6321 +>>>>>>> Stashed changes { - yyVAL.over = yyDollar[1].over + yyVAL.val = &Frame{} } +<<<<<<< Updated upstream case 1224: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6399 +======= + case 1225: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6325 +>>>>>>> Stashed changes { - yyVAL.frame = nil + yyVAL.val = &Frame{Unit: RowsUnit, Extent: yyDollar[2].val.(*FrameExtent)} } case 1225: yyDollar = yyS[yypt-2 : yypt+1] @@ -19816,16 +22219,24 @@ yydefault: } case 1226: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6407 +//line sql3.y:6329 { +<<<<<<< Updated upstream yyVAL.frame = &Frame{Unit: RangeUnit, Extent: yyDollar[2].frameExtent} } case 1227: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6414 +======= + yyVAL.val = &Frame{Unit: RangeUnit, Extent: yyDollar[2].val.(*FrameExtent)} + } + case 1227: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6336 +>>>>>>> Stashed changes { - startBound := yyDollar[2].frameBound - endBound := yyDollar[4].frameBound + startBound := yyDollar[2].val.(*FrameBound) + endBound := yyDollar[4].val.(*FrameBound) switch { case startBound.Type == UnboundedFollowing: yylex.Error("frame start cannot be UNBOUNDED FOLLOWING") @@ -19843,13 +22254,17 @@ yydefault: yylex.Error("frame starting from following row cannot have preceding rows") return 1 } - yyVAL.frameExtent = &FrameExtent{Start: startBound, End: endBound} + yyVAL.val = &FrameExtent{Start: startBound, End: endBound} } case 1228: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6437 +======= +//line sql3.y:6359 +>>>>>>> Stashed changes { - startBound := yyDollar[1].frameBound + startBound := yyDollar[1].val.(*FrameBound) switch { case startBound.Type == UnboundedFollowing: yylex.Error("frame start cannot be UNBOUNDED FOLLOWING") @@ -19858,7 +22273,13 @@ yydefault: yylex.Error("frame starting from following row cannot end with current row") return 1 } - yyVAL.frameExtent = &FrameExtent{Start: startBound} + yyVAL.val = &FrameExtent{Start: startBound} + } + case 1229: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6374 + { + yyVAL.val = &FrameBound{Type: UnboundedPreceding} } case 1229: yyDollar = yyS[yypt-2 : yypt+1] @@ -19868,89 +22289,162 @@ yydefault: } case 1230: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6456 +//line sql3.y:6378 { +<<<<<<< Updated upstream yyVAL.frameBound = &FrameBound{Type: UnboundedFollowing} +======= + yyVAL.val = &FrameBound{Type: UnboundedFollowing} +>>>>>>> Stashed changes } case 1231: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6460 +//line sql3.y:6382 { +<<<<<<< Updated upstream yyVAL.frameBound = &FrameBound{Type: CurrentRow} +======= + yyVAL.val = &FrameBound{Type: CurrentRow} +>>>>>>> Stashed changes } case 1232: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6464 +//line sql3.y:6386 { +<<<<<<< Updated upstream yyVAL.frameBound = &FrameBound{ Expr: yyDollar[1].expr, +======= + yyVAL.val = &FrameBound{ + Expr: yyDollar[1].val.(Expr), +>>>>>>> Stashed changes Type: ExprPreceding, } } case 1233: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6471 +======= +//line sql3.y:6393 +>>>>>>> Stashed changes { - yyVAL.frameBound = &FrameBound{ - Expr: yyDollar[1].expr, + yyVAL.val = &FrameBound{ + Expr: yyDollar[1].val.(Expr), Type: ExprFollowing, } } case 1234: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6479 +======= +//line sql3.y:6401 +>>>>>>> Stashed changes { - yyVAL.window = nil + yyVAL.val = Window(nil) } case 1235: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6404 + { + yyVAL.val = yyDollar[2].val.(Window) + } +<<<<<<< Updated upstream + case 1235: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6482 +======= + case 1236: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6410 +>>>>>>> Stashed changes { - yyVAL.window = yyDollar[2].window + yyVAL.val = Window{yyDollar[1].val.(*WindowDef)} } +<<<<<<< Updated upstream case 1236: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6488 +======= + case 1237: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6413 +>>>>>>> Stashed changes { - yyVAL.window = Window{yyDollar[1].windowDef} + yyVAL.val = append(yyDollar[1].val.(Window), yyDollar[3].val.(*WindowDef)) } case 1237: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6491 +======= +//line sql3.y:6419 +>>>>>>> Stashed changes { - yyVAL.window = append(yyDollar[1].window, yyDollar[3].windowDef) + def := yyDollar[3].val.(*WindowDef) + def.Name = yyDollar[1].val.(ColIdent) + yyVAL.val = def } +<<<<<<< Updated upstream case 1238: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6497 +======= + case 1264: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6459 +>>>>>>> Stashed changes { - def := yyDollar[3].windowDef - def.Name = yyDollar[1].colIdent - yyVAL.windowDef = def + yyVAL.val = NewIntVal(yyDollar[1].bytes) } +<<<<<<< Updated upstream case 1264: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6537 +======= + case 1265: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6463 +>>>>>>> Stashed changes { - yyVAL.expr = NewIntVal(yyDollar[1].bytes) + yyVAL.val = &IntervalExpr{Expr: yyDollar[2].val.(Expr), Unit: string(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1265: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6541 +======= + case 1266: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6468 +>>>>>>> Stashed changes { - yyVAL.expr = &IntervalExpr{Expr: yyDollar[2].expr, Unit: string(yyDollar[3].bytes)} + yyVAL.val = ColIdent{} } +<<<<<<< Updated upstream case 1266: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6546 +======= + case 1267: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6472 +>>>>>>> Stashed changes { - yyVAL.colIdent = ColIdent{} + yyVAL.val = yyDollar[1].val.(ColIdent) } +<<<<<<< Updated upstream case 1267: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6550 +======= + case 1268: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6476 +>>>>>>> Stashed changes { - yyVAL.colIdent = yyDollar[1].colIdent + yyVAL.val = yyDollar[2].val.(ColIdent) } case 1268: yyDollar = yyS[yypt-2 : yypt+1] @@ -19960,8 +22454,9 @@ yydefault: } case 1269: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6558 +//line sql3.y:6480 { +<<<<<<< Updated upstream yyVAL.colIdent = NewColIdent(string(yyDollar[2].bytes)) } case 1270: @@ -19969,21 +22464,31 @@ yydefault: //line sql.y:6564 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) +======= + yyVAL.val = NewColIdent(string(yyDollar[2].bytes)) + } + case 1270: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6486 + { + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) +>>>>>>> Stashed changes } case 1271: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6568 +//line sql3.y:6490 { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1272: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6572 +//line sql3.y:6494 { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1273: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6578 { yyVAL.tableExprs = TableExprs{yyDollar[1].tableExpr} @@ -19991,39 +22496,75 @@ yydefault: case 1274: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6582 +======= +//line sql3.y:6500 { - yyVAL.tableExprs = append(yyVAL.tableExprs, yyDollar[3].tableExpr) + yyVAL.val = TableExprs{yyDollar[1].val.(TableExpr)} + } + case 1274: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6504 +>>>>>>> Stashed changes + { + yyVAL.val = append(yyVAL.val.(TableExprs), yyDollar[3].val.(TableExpr)) } case 1277: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6592 +//line sql3.y:6514 { - yyVAL.tableExpr = yyDollar[1].aliasedTableName + yyVAL.val = yyDollar[1].val.(*AliasedTableExpr) } +<<<<<<< Updated upstream + case 1277: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql.y:6592 +======= case 1278: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6596 +//line sql3.y:6518 +>>>>>>> Stashed changes { - switch n := yyDollar[1].simpleTableExpr.(type) { + switch n := yyDollar[1].val.(SimpleTableExpr).(type) { case *Subquery: - n.Columns = yyDollar[4].columns + n.Columns = yyDollar[4].val.(Columns) case *ValuesStatement: - n.Columns = yyDollar[4].columns + n.Columns = yyDollar[4].val.(Columns) } - yyVAL.tableExpr = &AliasedTableExpr{Lateral: false, Expr: yyDollar[1].simpleTableExpr, As: yyDollar[3].tableIdent} + yyVAL.val = &AliasedTableExpr{Lateral: false, Expr: yyDollar[1].val.(SimpleTableExpr), As: yyDollar[3].val.(TableIdent)} } +<<<<<<< Updated upstream + case 1278: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql.y:6596 +======= case 1279: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:6606 +//line sql3.y:6528 +>>>>>>> Stashed changes { - switch n := yyDollar[2].simpleTableExpr.(type) { + switch n := yyDollar[2].val.(SimpleTableExpr).(type) { case *Subquery: - n.Columns = yyDollar[5].columns + n.Columns = yyDollar[5].val.(Columns) case *ValuesStatement: - n.Columns = yyDollar[5].columns + n.Columns = yyDollar[5].val.(Columns) } - yyVAL.tableExpr = &AliasedTableExpr{Lateral: true, Expr: yyDollar[2].simpleTableExpr, As: yyDollar[4].tableIdent} + yyVAL.val = &AliasedTableExpr{Lateral: true, Expr: yyDollar[2].val.(SimpleTableExpr), As: yyDollar[4].val.(TableIdent)} } +<<<<<<< Updated upstream + case 1279: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql.y:6606 +======= + case 1280: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6538 +>>>>>>> Stashed changes + { + // missed alias for subquery + yylex.Error("Every derived table must have its own alias") + return 1 + } +<<<<<<< Updated upstream case 1280: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6616 @@ -20035,6 +22576,11 @@ yydefault: case 1281: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6622 +======= + case 1281: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6544 +>>>>>>> Stashed changes { // missed alias for subquery yylex.Error("Every derived table must have its own alias") @@ -20042,28 +22588,54 @@ yydefault: } case 1282: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6628 +======= +//line sql3.y:6550 +>>>>>>> Stashed changes { - yyVAL.tableExpr = &ParenTableExpr{Exprs: yyDollar[2].tableExprs} + yyVAL.val = &ParenTableExpr{Exprs: yyDollar[2].val.(TableExprs)} } case 1285: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6558 + { + yyVAL.val = &ValuesStatement{Rows: yyDollar[2].val.(Values)} + } + case 1285: + yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6636 +======= +//line sql3.y:6564 +>>>>>>> Stashed changes { - yyVAL.simpleTableExpr = &ValuesStatement{Rows: yyDollar[2].values} + yyVAL.val = Values{yyDollar[2].val.(ValTuple)} } +<<<<<<< Updated upstream case 1286: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6642 +======= + case 1287: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6568 +>>>>>>> Stashed changes { - yyVAL.values = Values{yyDollar[2].valTuple} + yyVAL.val = append(yyVAL.val.(Values), yyDollar[4].val.(ValTuple)) } +<<<<<<< Updated upstream case 1287: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6646 +======= + case 1288: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6573 +>>>>>>> Stashed changes { - yyVAL.values = append(yyVAL.values, yyDollar[4].valTuple) } +<<<<<<< Updated upstream case 1288: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6651 @@ -20072,46 +22644,91 @@ yydefault: case 1289: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6653 +======= + case 1289: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6575 +>>>>>>> Stashed changes { } case 1290: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6657 +======= +//line sql3.y:6579 + { + yyVAL.val = yyDollar[2].val.(*AliasedTableExpr) + yyVAL.val.(*AliasedTableExpr).Expr = yyDollar[1].val.(TableName) + } + case 1291: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:6584 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = yyDollar[2].aliasedTableName - yyVAL.aliasedTableName.Expr = yyDollar[1].tableName + yyVAL.val = yyDollar[6].val.(*AliasedTableExpr) + yyVAL.val.(*AliasedTableExpr).Expr = yyDollar[1].val.(TableName) + yyVAL.val.(*AliasedTableExpr).Partitions = yyDollar[4].val.(Partitions) } +<<<<<<< Updated upstream case 1291: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:6662 +======= + case 1292: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6594 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = yyDollar[6].aliasedTableName - yyVAL.aliasedTableName.Expr = yyDollar[1].tableName - yyVAL.aliasedTableName.Partitions = yyDollar[4].partitions + yyVAL.val = &AliasedTableExpr{Hints: yyDollar[1].val.(*IndexHints)} } +<<<<<<< Updated upstream case 1292: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6672 +======= + case 1293: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6598 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = &AliasedTableExpr{Hints: yyDollar[1].indexHints} + yyVAL.val = &AliasedTableExpr{As: yyDollar[2].val.(TableIdent), Hints: yyDollar[3].val.(*IndexHints)} } +<<<<<<< Updated upstream case 1293: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6676 +======= + case 1294: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6602 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = &AliasedTableExpr{As: yyDollar[2].tableIdent, Hints: yyDollar[3].indexHints} + yyVAL.val = &AliasedTableExpr{AsOf: yyDollar[1].val.(*AsOf), Hints: yyDollar[2].val.(*IndexHints)} } +<<<<<<< Updated upstream case 1294: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6680 +======= + case 1295: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6606 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = &AliasedTableExpr{AsOf: yyDollar[1].asOf, Hints: yyDollar[2].indexHints} + yyVAL.val = &AliasedTableExpr{AsOf: yyDollar[1].val.(*AsOf), As: yyDollar[3].val.(TableIdent), Hints: yyDollar[4].val.(*IndexHints)} } +<<<<<<< Updated upstream case 1295: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6684 +======= + case 1296: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6612 +>>>>>>> Stashed changes { - yyVAL.aliasedTableName = &AliasedTableExpr{AsOf: yyDollar[1].asOf, As: yyDollar[3].tableIdent, Hints: yyDollar[4].indexHints} + yyVAL.val = yyDollar[1].val.(*AsOf) } case 1296: yyDollar = yyS[yypt-1 : yypt+1] @@ -20121,45 +22738,65 @@ yydefault: } case 1297: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6694 +//line sql3.y:6616 { - yyVAL.asOf = yyDollar[1].asOf + yyVAL.val = yyDollar[1].val.(*AsOf) } case 1298: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6698 +//line sql3.y:6620 { - yyVAL.asOf = yyDollar[1].asOf + yyVAL.val = yyDollar[1].val.(*AsOf) } case 1299: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6702 +//line sql3.y:6624 { - yyVAL.asOf = yyDollar[1].asOf + yyVAL.val = yyDollar[1].val.(*AsOf) } case 1300: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:6706 +//line sql3.y:6628 { - yyVAL.asOf = yyDollar[1].asOf + yyVAL.val = yyDollar[1].val.(*AsOf) } case 1301: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6712 { yyVAL.asOf = &AsOf{Start: yyDollar[3].expr, End: yyDollar[5].expr, EndInclusive: true} +======= +//line sql3.y:6634 + { + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr), EndInclusive: true} +>>>>>>> Stashed changes } case 1302: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:6716 +//line sql3.y:6638 { +<<<<<<< Updated upstream yyVAL.asOf = &AsOf{Start: yyDollar[3].expr, End: yyDollar[5].expr} } case 1303: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:6720 +======= + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr)} + } + case 1303: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:6642 { - yyVAL.asOf = &AsOf{Start: yyDollar[5].expr, End: yyDollar[7].expr, StartInclusive: true, EndInclusive: true} + yyVAL.val = &AsOf{Start: yyDollar[5].val.(Expr), End: yyDollar[7].val.(Expr), StartInclusive: true, EndInclusive: true} + } + case 1304: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:6648 +>>>>>>> Stashed changes + { + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr), EndInclusive: true} } case 1304: yyDollar = yyS[yypt-5 : yypt+1] @@ -20169,15 +22806,29 @@ yydefault: } case 1305: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:6730 +//line sql3.y:6652 { +<<<<<<< Updated upstream yyVAL.asOf = &AsOf{Start: yyDollar[3].expr, End: yyDollar[5].expr} } case 1306: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:6734 +======= + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr)} + } + case 1306: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:6656 { - yyVAL.asOf = &AsOf{Start: yyDollar[5].expr, End: yyDollar[7].expr, StartInclusive: true, EndInclusive: true} + yyVAL.val = &AsOf{Start: yyDollar[5].val.(Expr), End: yyDollar[7].val.(Expr), StartInclusive: true, EndInclusive: true} + } + case 1307: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:6660 +>>>>>>> Stashed changes + { + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr), EndInclusive: true} } case 1307: yyDollar = yyS[yypt-5 : yypt+1] @@ -20187,15 +22838,29 @@ yydefault: } case 1308: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:6742 +//line sql3.y:6664 { +<<<<<<< Updated upstream yyVAL.asOf = &AsOf{Start: yyDollar[3].expr, End: yyDollar[5].expr} } case 1309: yyDollar = yyS[yypt-8 : yypt+1] //line sql.y:6746 +======= + yyVAL.val = &AsOf{Start: yyDollar[3].val.(Expr), End: yyDollar[5].val.(Expr)} + } + case 1309: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:6668 + { + yyVAL.val = &AsOf{Start: yyDollar[5].val.(Expr), End: yyDollar[7].val.(Expr), StartInclusive: true, EndInclusive: true} + } + case 1310: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6674 +>>>>>>> Stashed changes { - yyVAL.asOf = &AsOf{Start: yyDollar[5].expr, End: yyDollar[7].expr, StartInclusive: true, EndInclusive: true} + yyVAL.val = &AsOf{All: true} } case 1310: yyDollar = yyS[yypt-2 : yypt+1] @@ -20205,21 +22870,35 @@ yydefault: } case 1311: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6758 +======= +//line sql3.y:6680 +>>>>>>> Stashed changes { - yyVAL.asOf = &AsOf{All: true} + yyVAL.val = &AsOf{All: true} } case 1312: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6762 +//line sql3.y:6684 { - yyVAL.asOf = &AsOf{All: true} + yyVAL.val = &AsOf{All: true} } case 1313: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6768 +======= +//line sql3.y:6690 { - yyVAL.asOf = &AsOf{Time: yyDollar[3].expr} + yyVAL.val = &AsOf{Time: yyDollar[3].val.(Expr)} + } + case 1314: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6694 +>>>>>>> Stashed changes + { + yyVAL.val = &AsOf{Time: yyDollar[4].val.(Expr)} } case 1314: yyDollar = yyS[yypt-4 : yypt+1] @@ -20229,81 +22908,157 @@ yydefault: } case 1315: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6776 +//line sql3.y:6698 { - yyVAL.asOf = &AsOf{Time: yyDollar[4].expr} + yyVAL.val = &AsOf{Time: yyDollar[4].val.(Expr)} } case 1316: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6781 +======= +//line sql3.y:6703 { - yyVAL.expr = nil + yyVAL.val = Expr(nil) } case 1317: yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6707 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(*AsOf).Time + } +<<<<<<< Updated upstream + case 1317: + yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6785 +======= + case 1318: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6713 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].asOf.Time + yyVAL.val = yyDollar[2].val.(Columns) } +<<<<<<< Updated upstream case 1318: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6791 +======= + case 1319: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6717 +>>>>>>> Stashed changes { - yyVAL.columns = yyDollar[2].columns + yyVAL.val = yyDollar[1].val.(Columns) } +<<<<<<< Updated upstream case 1319: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6795 +======= + case 1320: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6722 +>>>>>>> Stashed changes { - yyVAL.columns = yyDollar[1].columns + yyVAL.val = Columns(nil) } +<<<<<<< Updated upstream case 1320: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6800 +======= + case 1321: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6726 +>>>>>>> Stashed changes { - yyVAL.columns = nil + yyVAL.val = yyDollar[2].val.(Columns) } +<<<<<<< Updated upstream case 1321: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6804 +======= + case 1322: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6732 +>>>>>>> Stashed changes { - yyVAL.columns = yyDollar[2].columns + yyVAL.val = Columns{yyDollar[1].val.(ColIdent)} } +<<<<<<< Updated upstream case 1322: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6810 +======= + case 1323: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6736 +>>>>>>> Stashed changes { - yyVAL.columns = Columns{yyDollar[1].colIdent} + yyVAL.val = append(yyVAL.val.(Columns), yyDollar[3].val.(ColIdent)) } +<<<<<<< Updated upstream case 1323: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6814 +======= + case 1324: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6742 +>>>>>>> Stashed changes { - yyVAL.columns = append(yyVAL.columns, yyDollar[3].colIdent) + yyVAL.val = Partitions{yyDollar[1].val.(ColIdent)} } +<<<<<<< Updated upstream case 1324: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6820 +======= + case 1325: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6746 +>>>>>>> Stashed changes { - yyVAL.partitions = Partitions{yyDollar[1].colIdent} + yyVAL.val = append(yyVAL.val.(Partitions), yyDollar[3].val.(ColIdent)) } +<<<<<<< Updated upstream case 1325: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6824 +======= + case 1326: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6752 +>>>>>>> Stashed changes { - yyVAL.partitions = append(yyVAL.partitions, yyDollar[3].colIdent) + yyVAL.val = &TableFuncExpr{Name: string(yyDollar[1].bytes), Exprs: yyDollar[3].val.(SelectExprs)} } +<<<<<<< Updated upstream case 1326: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6830 +======= + case 1327: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:6756 +>>>>>>> Stashed changes { - yyVAL.tableExpr = &TableFuncExpr{Name: string(yyDollar[1].bytes), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &TableFuncExpr{Name: string(yyDollar[1].bytes), Exprs: yyDollar[3].val.(SelectExprs), Alias: yyDollar[6].val.(TableIdent)} } +<<<<<<< Updated upstream case 1327: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:6834 +======= + case 1328: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6770 +>>>>>>> Stashed changes { - yyVAL.tableExpr = &TableFuncExpr{Name: string(yyDollar[1].bytes), Exprs: yyDollar[3].selectExprs, Alias: yyDollar[6].tableIdent} + yyVAL.val = &JoinTableExpr{LeftExpr: yyDollar[1].val.(TableExpr), Join: yyDollar[2].val.(string), RightExpr: yyDollar[3].val.(TableExpr), Condition: yyDollar[4].val.(JoinCondition)} } case 1328: yyDollar = yyS[yypt-4 : yypt+1] @@ -20313,46 +23068,81 @@ yydefault: } case 1329: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6852 +//line sql3.y:6774 { - yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr, Condition: yyDollar[4].joinCondition} + yyVAL.val = &JoinTableExpr{LeftExpr: yyDollar[1].val.(TableExpr), Join: yyDollar[2].val.(string), RightExpr: yyDollar[3].val.(TableExpr), Condition: yyDollar[4].val.(JoinCondition)} } case 1330: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:6856 +//line sql3.y:6778 { - yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr, Condition: yyDollar[4].joinCondition} + yyVAL.val = &JoinTableExpr{LeftExpr: yyDollar[1].val.(TableExpr), Join: yyDollar[2].val.(string), RightExpr: yyDollar[3].val.(TableExpr), Condition: yyDollar[4].val.(JoinCondition)} } case 1331: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6860 +======= +//line sql3.y:6782 + { + yyVAL.val = &JoinTableExpr{LeftExpr: yyDollar[1].val.(TableExpr), Join: yyDollar[2].val.(string), RightExpr: yyDollar[3].val.(TableExpr)} + } + case 1332: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6788 +>>>>>>> Stashed changes { - yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr} + yyVAL.val = JoinCondition{On: yyDollar[2].val.(Expr)} } +<<<<<<< Updated upstream case 1332: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6866 +======= + case 1333: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6790 +>>>>>>> Stashed changes { - yyVAL.joinCondition = JoinCondition{On: yyDollar[2].expr} + yyVAL.val = JoinCondition{Using: yyDollar[3].val.(Columns)} } +<<<<<<< Updated upstream case 1333: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:6868 +======= + case 1334: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6794 +>>>>>>> Stashed changes { - yyVAL.joinCondition = JoinCondition{Using: yyDollar[3].columns} + yyVAL.val = JoinCondition{} } +<<<<<<< Updated upstream case 1334: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6872 +======= + case 1335: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6796 +>>>>>>> Stashed changes { - yyVAL.joinCondition = JoinCondition{} + yyVAL.val = yyDollar[1].val.(JoinCondition) } +<<<<<<< Updated upstream case 1335: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6874 +======= + case 1336: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:6800 +>>>>>>> Stashed changes { - yyVAL.joinCondition = yyDollar[1].joinCondition + yyVAL.val = JoinCondition{} } +<<<<<<< Updated upstream case 1336: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:6878 @@ -20362,15 +23152,31 @@ yydefault: case 1337: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6880 +======= + case 1337: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6802 +>>>>>>> Stashed changes + { + yyVAL.val = JoinCondition{On: yyDollar[2].val.(Expr)} + } + case 1339: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6807 { - yyVAL.joinCondition = JoinCondition{On: yyDollar[2].expr} + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) } case 1339: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6885 +======= +//line sql3.y:6813 +>>>>>>> Stashed changes { - yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) + yyVAL.val = JoinStr } +<<<<<<< Updated upstream case 1340: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6891 @@ -20380,21 +23186,37 @@ yydefault: case 1341: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6895 +======= + case 1341: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6817 +>>>>>>> Stashed changes { - yyVAL.str = JoinStr + yyVAL.val = JoinStr } case 1342: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6899 +//line sql3.y:6821 { - yyVAL.str = JoinStr + yyVAL.val = JoinStr } case 1343: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6905 +======= +//line sql3.y:6827 + { + yyVAL.val = StraightJoinStr + } + case 1344: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6833 +>>>>>>> Stashed changes { - yyVAL.str = StraightJoinStr + yyVAL.val = LeftJoinStr } +<<<<<<< Updated upstream case 1344: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6911 @@ -20404,11 +23226,17 @@ yydefault: case 1345: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6915 +======= + case 1345: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6837 +>>>>>>> Stashed changes { - yyVAL.str = LeftJoinStr + yyVAL.val = LeftJoinStr } case 1346: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6919 { yyVAL.str = RightJoinStr @@ -20416,56 +23244,104 @@ yydefault: case 1347: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:6923 +======= +//line sql3.y:6841 { - yyVAL.str = RightJoinStr + yyVAL.val = RightJoinStr + } + case 1347: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6845 +>>>>>>> Stashed changes + { + yyVAL.val = RightJoinStr } case 1348: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:6927 +//line sql3.y:6849 { +<<<<<<< Updated upstream yyVAL.str = FullOuterJoinStr } case 1349: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6931 +======= + yyVAL.val = FullOuterJoinStr + } + case 1349: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6853 +>>>>>>> Stashed changes { - yyVAL.str = FullOuterJoinStr + yyVAL.val = FullOuterJoinStr } case 1350: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6937 { yyVAL.str = NaturalJoinStr +======= +//line sql3.y:6859 + { + yyVAL.val = NaturalJoinStr +>>>>>>> Stashed changes } case 1351: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:6941 +//line sql3.y:6863 { +<<<<<<< Updated upstream if yyDollar[2].str == LeftJoinStr { yyVAL.str = NaturalLeftJoinStr +======= + if yyDollar[2].val.(string) == LeftJoinStr { + yyVAL.val = NaturalLeftJoinStr +>>>>>>> Stashed changes } else { - yyVAL.str = NaturalRightJoinStr + yyVAL.val = NaturalRightJoinStr } } case 1352: yyDollar = yyS[yypt-12 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6951 +======= +//line sql3.y:6873 +>>>>>>> Stashed changes + { + yyDollar[8].val.(*JSONTableSpec).Path = string(yyDollar[5].bytes) + yyVAL.val = &JSONTableExpr{Data: yyDollar[3].val.(Expr), Spec: yyDollar[8].val.(*JSONTableSpec), Alias: yyDollar[12].val.(TableIdent)} + } + case 1353: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6880 { - yyDollar[8].JSONTableSpec.Path = string(yyDollar[5].bytes) - yyVAL.tableExpr = &JSONTableExpr{Data: yyDollar[3].expr, Spec: yyDollar[8].JSONTableSpec, Alias: yyDollar[12].tableIdent} + yyVAL.val = &JSONTableSpec{} + yyVAL.val.(*JSONTableSpec).AddColumn(yyDollar[1].val.(*JSONTableColDef)) } +<<<<<<< Updated upstream case 1353: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:6958 +======= + case 1354: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6885 +>>>>>>> Stashed changes { - yyVAL.JSONTableSpec = &JSONTableSpec{} - yyVAL.JSONTableSpec.AddColumn(yyDollar[1].JSONTableColDef) + yyVAL.val.(*JSONTableSpec).AddColumn(yyDollar[3].val.(*JSONTableColDef)) } case 1354: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:6963 +======= +//line sql3.y:6891 +>>>>>>> Stashed changes { - yyVAL.JSONTableSpec.AddColumn(yyDollar[3].JSONTableColDef) + yyVAL.val = &JSONTableColDef{Name: yyDollar[1].val.(ColIdent), Type: yyDollar[2].val.(ColumnType), Opts: yyDollar[3].val.(JSONTableColOpts)} } case 1355: yyDollar = yyS[yypt-3 : yypt+1] @@ -20475,29 +23351,55 @@ yydefault: } case 1356: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:6973 +//line sql3.y:6895 { +<<<<<<< Updated upstream yyVAL.JSONTableColDef = &JSONTableColDef{Name: yyDollar[1].colIdent, Type: ColumnType{Type: "INTEGER", Unsigned: true, Autoincrement: true}} } case 1357: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:6977 +======= + yyVAL.val = &JSONTableColDef{Name: yyDollar[1].val.(ColIdent), Type: ColumnType{Type: "INTEGER", Unsigned: true, Autoincrement: true}} + } + case 1357: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:6899 { - yyDollar[5].JSONTableSpec.Path = string(yyDollar[2].bytes) - yyVAL.JSONTableColDef = &JSONTableColDef{Spec: yyDollar[5].JSONTableSpec} + yyDollar[5].val.(*JSONTableSpec).Path = string(yyDollar[2].bytes) + yyVAL.val = &JSONTableColDef{Spec: yyDollar[5].val.(*JSONTableSpec)} } case 1358: yyDollar = yyS[yypt-7 : yypt+1] +//line sql3.y:6904 +>>>>>>> Stashed changes + { + yyDollar[6].val.(*JSONTableSpec).Path = string(yyDollar[3].bytes) + yyVAL.val = &JSONTableColDef{Spec: yyDollar[6].val.(*JSONTableSpec)} + } +<<<<<<< Updated upstream + case 1358: + yyDollar = yyS[yypt-7 : yypt+1] //line sql.y:6982 +======= + case 1359: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6911 +>>>>>>> Stashed changes { - yyDollar[6].JSONTableSpec.Path = string(yyDollar[3].bytes) - yyVAL.JSONTableColDef = &JSONTableColDef{Spec: yyDollar[6].JSONTableSpec} + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes)} } +<<<<<<< Updated upstream case 1359: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:6989 +======= + case 1360: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6915 +>>>>>>> Stashed changes { - yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes)} + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnEmpty: yyDollar[3].val.(Expr)} } case 1360: yyDollar = yyS[yypt-3 : yypt+1] @@ -20507,8 +23409,9 @@ yydefault: } case 1361: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:6997 +//line sql3.y:6919 { +<<<<<<< Updated upstream yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnError: yyDollar[3].expr} } case 1362: @@ -20516,11 +23419,21 @@ yydefault: //line sql.y:7001 { yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnEmpty: yyDollar[3].expr, ValOnError: yyDollar[4].expr} +======= + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnError: yyDollar[3].val.(Expr)} + } + case 1362: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6923 + { + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnEmpty: yyDollar[3].val.(Expr), ValOnError: yyDollar[4].val.(Expr)} +>>>>>>> Stashed changes } case 1363: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7005 +//line sql3.y:6927 { +<<<<<<< Updated upstream yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnEmpty: yyDollar[4].expr, ValOnError: yyDollar[3].expr} } case 1364: @@ -20528,11 +23441,21 @@ yydefault: //line sql.y:7009 { yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true} +======= + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ValOnEmpty: yyDollar[4].val.(Expr), ValOnError: yyDollar[3].val.(Expr)} + } + case 1364: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:6931 + { + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true} +>>>>>>> Stashed changes } case 1365: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7013 +//line sql3.y:6935 { +<<<<<<< Updated upstream yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnError: true} } case 1366: @@ -20540,19 +23463,40 @@ yydefault: //line sql.y:7017 { yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true, ErrorOnError: true} +======= + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnError: true} + } + case 1366: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:6939 + { + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true, ErrorOnError: true} +>>>>>>> Stashed changes } case 1367: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:7021 +//line sql3.y:6943 { - yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true, ErrorOnError: true} + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[2].bytes), ErrorOnEmpty: true, ErrorOnError: true} } case 1368: +<<<<<<< Updated upstream yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7025 +======= + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6947 + { + yyVAL.val = JSONTableColOpts{Path: string(yyDollar[3].bytes), Exists: true} + } + case 1369: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6953 +>>>>>>> Stashed changes { - yyVAL.JSONTableColOpts = JSONTableColOpts{Path: string(yyDollar[3].bytes), Exists: true} + yyVAL.val = &NullVal{} } +<<<<<<< Updated upstream case 1369: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7031 @@ -20568,56 +23512,117 @@ yydefault: case 1371: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7041 +======= + case 1370: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6957 { - yyVAL.expr = &NullVal{} + yyVAL.val = yyDollar[2].val.(Expr) + } + case 1371: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6963 + { + yyVAL.val = &NullVal{} + } + case 1372: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:6967 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[2].val.(Expr) } +<<<<<<< Updated upstream case 1372: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7045 +======= + case 1373: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6973 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[2].expr + yyVAL.val = TriggerName{Name: yyDollar[1].val.(ColIdent)} } +<<<<<<< Updated upstream case 1373: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7051 +======= + case 1374: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:6977 +>>>>>>> Stashed changes { - yyVAL.triggerName = TriggerName{Name: yyDollar[1].colIdent} + yyVAL.val = TriggerName{Qualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(ColIdent)} } case 1374: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7055 +======= +//line sql3.y:6983 +>>>>>>> Stashed changes { - yyVAL.triggerName = TriggerName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].colIdent} + yyVAL.val = yyDollar[3].val.(TableName) } +<<<<<<< Updated upstream case 1375: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7061 +======= + case 1376: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:6989 +>>>>>>> Stashed changes { - yyVAL.tableName = yyDollar[3].tableName + yyVAL.val = yyDollar[2].val.(TableName) } +<<<<<<< Updated upstream case 1376: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7067 +======= + case 1377: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:6993 +>>>>>>> Stashed changes { - yyVAL.tableName = yyDollar[2].tableName + yyVAL.val = yyDollar[1].val.(TableName) } case 1377: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7071 +======= +//line sql3.y:6999 +>>>>>>> Stashed changes { - yyVAL.tableName = yyDollar[1].tableName + yyVAL.val = TableName{Name: yyDollar[1].val.(TableIdent)} } +<<<<<<< Updated upstream case 1378: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7077 +======= + case 1379: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7003 +>>>>>>> Stashed changes { - yyVAL.tableName = TableName{Name: yyDollar[1].tableIdent} + yyVAL.val = TableName{DbQualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(TableIdent)} } +<<<<<<< Updated upstream case 1379: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7081 +======= + case 1380: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7007 +>>>>>>> Stashed changes { - yyVAL.tableName = TableName{DbQualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent} + yyVAL.val = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} } case 1380: yyDollar = yyS[yypt-1 : yypt+1] @@ -20627,45 +23632,71 @@ yydefault: } case 1381: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7089 +//line sql3.y:7011 { - yyVAL.tableName = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} + yyVAL.val = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} } case 1382: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7093 +//line sql3.y:7015 { - yyVAL.tableName = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} + yyVAL.val = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} } case 1383: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7097 +//line sql3.y:7019 { - yyVAL.tableName = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} + yyVAL.val = TableName{Name: NewTableIdent(string(yyDollar[1].bytes))} } case 1384: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7103 +======= +//line sql3.y:7025 + { + yyVAL.val = ProcedureName{Name: yyDollar[1].val.(ColIdent)} + } + case 1385: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7029 +>>>>>>> Stashed changes { - yyVAL.procedureName = ProcedureName{Name: yyDollar[1].colIdent} + yyVAL.val = ProcedureName{Qualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(ColIdent)} } case 1385: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7107 +======= +//line sql3.y:7035 +>>>>>>> Stashed changes { - yyVAL.procedureName = ProcedureName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].colIdent} + yyVAL.val = TableName{Name: yyDollar[1].val.(TableIdent)} } +<<<<<<< Updated upstream case 1386: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7113 +======= + case 1387: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:7040 +>>>>>>> Stashed changes { - yyVAL.tableName = TableName{Name: yyDollar[1].tableIdent} + yyVAL.val = &IndexHints{} } +<<<<<<< Updated upstream case 1387: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:7118 +======= + case 1388: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7044 +>>>>>>> Stashed changes { - yyVAL.indexHints = nil + yyVAL.val = &IndexHints{Type: UseStr, Indexes: yyDollar[4].val.(Columns)} } case 1388: yyDollar = yyS[yypt-5 : yypt+1] @@ -20675,33 +23706,63 @@ yydefault: } case 1389: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7126 +//line sql3.y:7048 { +<<<<<<< Updated upstream yyVAL.indexHints = &IndexHints{Type: IgnoreStr, Indexes: yyDollar[4].columns} +======= + yyVAL.val = &IndexHints{Type: IgnoreStr, Indexes: yyDollar[4].val.(Columns)} +>>>>>>> Stashed changes } case 1390: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7130 +//line sql3.y:7052 { +<<<<<<< Updated upstream yyVAL.indexHints = &IndexHints{Type: ForceStr, Indexes: yyDollar[4].columns} } case 1391: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:7135 +======= + yyVAL.val = &IndexHints{Type: ForceStr, Indexes: yyDollar[4].val.(Columns)} + } + case 1391: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:7057 { - yyVAL.expr = nil + yyVAL.val = Expr(nil) } case 1392: yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7061 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[2].val.(Expr) + } +<<<<<<< Updated upstream + case 1392: + yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7139 +======= + case 1393: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7067 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[2].expr + yyVAL.val = yyDollar[1].val.(Expr) } +<<<<<<< Updated upstream case 1393: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7145 +======= + case 1394: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7071 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = &AndExpr{Left: yyDollar[1].val.(Expr), Right: yyDollar[3].val.(Expr)} } case 1394: yyDollar = yyS[yypt-3 : yypt+1] @@ -20711,51 +23772,99 @@ yydefault: } case 1395: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7153 +//line sql3.y:7075 { +<<<<<<< Updated upstream yyVAL.expr = &OrExpr{Left: yyDollar[1].expr, Right: yyDollar[3].expr} +======= + yyVAL.val = &OrExpr{Left: yyDollar[1].val.(Expr), Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1396: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7157 +//line sql3.y:7079 { +<<<<<<< Updated upstream yyVAL.expr = &XorExpr{Left: yyDollar[1].expr, Right: yyDollar[3].expr} } case 1397: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7161 +======= + yyVAL.val = &XorExpr{Left: yyDollar[1].val.(Expr), Right: yyDollar[3].val.(Expr)} + } + case 1397: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7083 + { + yyVAL.val = &NotExpr{Expr: yyDollar[2].val.(Expr)} + } + case 1398: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7087 +>>>>>>> Stashed changes { - yyVAL.expr = &NotExpr{Expr: yyDollar[2].expr} + yyVAL.val = &IsExpr{Operator: yyDollar[3].val.(string), Expr: yyDollar[1].val.(Expr)} } +<<<<<<< Updated upstream case 1398: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7165 +======= + case 1399: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7091 +>>>>>>> Stashed changes { - yyVAL.expr = &IsExpr{Operator: yyDollar[3].str, Expr: yyDollar[1].expr} + yyVAL.val = yyDollar[1].val.(Expr) } +<<<<<<< Updated upstream case 1399: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7169 +======= + case 1400: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7095 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = &Default{ColName: yyDollar[2].val.(string)} } +<<<<<<< Updated upstream case 1400: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7173 +======= + case 1401: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:7101 +>>>>>>> Stashed changes { - yyVAL.expr = &Default{ColName: yyDollar[2].str} + yyVAL.val = "" } +<<<<<<< Updated upstream case 1401: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:7179 +======= + case 1402: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7105 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = string(yyDollar[2].bytes) } +<<<<<<< Updated upstream case 1402: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7183 +======= + case 1403: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7111 +>>>>>>> Stashed changes { - yyVAL.str = string(yyDollar[2].bytes) + yyVAL.val = BoolVal(true) } case 1403: yyDollar = yyS[yypt-1 : yypt+1] @@ -20765,8 +23874,9 @@ yydefault: } case 1404: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7193 +//line sql3.y:7115 { +<<<<<<< Updated upstream yyVAL.boolVal = BoolVal(false) } case 1405: @@ -20774,11 +23884,21 @@ yydefault: //line sql.y:7199 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: yyDollar[2].str, Right: yyDollar[3].expr} +======= + yyVAL.val = BoolVal(false) + } + case 1405: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7121 + { + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: yyDollar[2].val.(string), Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1406: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7203 +//line sql3.y:7125 { +<<<<<<< Updated upstream yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: InStr, Right: yyDollar[3].colTuple} } case 1407: @@ -20786,84 +23906,173 @@ yydefault: //line sql.y:7207 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotInStr, Right: yyDollar[4].colTuple} +======= + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: InStr, Right: yyDollar[3].val.(ColTuple)} + } + case 1407: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7129 + { + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: NotInStr, Right: yyDollar[4].val.(ColTuple)} +>>>>>>> Stashed changes } case 1408: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7211 +//line sql3.y:7133 { +<<<<<<< Updated upstream yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: LikeStr, Right: yyDollar[3].expr, Escape: yyDollar[4].expr} } case 1409: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:7215 +======= + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: LikeStr, Right: yyDollar[3].val.(Expr), Escape: yyDollar[4].val.(Expr)} + } + case 1409: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7137 + { + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: NotLikeStr, Right: yyDollar[4].val.(Expr), Escape: yyDollar[5].val.(Expr)} + } + case 1410: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7141 +>>>>>>> Stashed changes { - yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotLikeStr, Right: yyDollar[4].expr, Escape: yyDollar[5].expr} + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: RegexpStr, Right: yyDollar[3].val.(Expr)} } +<<<<<<< Updated upstream case 1410: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7219 +======= + case 1411: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7145 +>>>>>>> Stashed changes { - yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: RegexpStr, Right: yyDollar[3].expr} + yyVAL.val = &ComparisonExpr{Left: yyDollar[1].val.(Expr), Operator: NotRegexpStr, Right: yyDollar[4].val.(Expr)} } +<<<<<<< Updated upstream case 1411: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7223 +======= + case 1412: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7149 +>>>>>>> Stashed changes { - yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotRegexpStr, Right: yyDollar[4].expr} + yyVAL.val = &RangeCond{Left: yyDollar[1].val.(Expr), Operator: BetweenStr, From: yyDollar[3].val.(Expr), To: yyDollar[5].val.(Expr)} } +<<<<<<< Updated upstream case 1412: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:7227 +======= + case 1413: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7153 +>>>>>>> Stashed changes { - yyVAL.expr = &RangeCond{Left: yyDollar[1].expr, Operator: BetweenStr, From: yyDollar[3].expr, To: yyDollar[5].expr} + yyVAL.val = &RangeCond{Left: yyDollar[1].val.(Expr), Operator: NotBetweenStr, From: yyDollar[4].val.(Expr), To: yyDollar[6].val.(Expr)} } +<<<<<<< Updated upstream case 1413: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:7231 +======= + case 1414: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7157 +>>>>>>> Stashed changes { - yyVAL.expr = &RangeCond{Left: yyDollar[1].expr, Operator: NotBetweenStr, From: yyDollar[4].expr, To: yyDollar[6].expr} + yyVAL.val = &ExistsExpr{Subquery: yyDollar[2].val.(*Subquery)} } +<<<<<<< Updated upstream case 1414: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7235 +======= + case 1415: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7163 +>>>>>>> Stashed changes { - yyVAL.expr = &ExistsExpr{Subquery: yyDollar[2].subquery} + yyVAL.val = IsNullStr } +<<<<<<< Updated upstream case 1415: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7241 +======= + case 1416: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7167 +>>>>>>> Stashed changes { - yyVAL.str = IsNullStr + yyVAL.val = IsNotNullStr } +<<<<<<< Updated upstream case 1416: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7245 +======= + case 1417: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7171 +>>>>>>> Stashed changes { - yyVAL.str = IsNotNullStr + yyVAL.val = IsTrueStr } +<<<<<<< Updated upstream case 1417: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7249 +======= + case 1418: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7175 +>>>>>>> Stashed changes { - yyVAL.str = IsTrueStr + yyVAL.val = IsNotTrueStr } +<<<<<<< Updated upstream case 1418: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7253 +======= + case 1419: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7179 +>>>>>>> Stashed changes { - yyVAL.str = IsNotTrueStr + yyVAL.val = IsFalseStr } +<<<<<<< Updated upstream case 1419: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7257 +======= + case 1420: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7183 +>>>>>>> Stashed changes { - yyVAL.str = IsFalseStr + yyVAL.val = IsNotFalseStr } +<<<<<<< Updated upstream case 1420: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7261 +======= + case 1421: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7189 +>>>>>>> Stashed changes { - yyVAL.str = IsNotFalseStr + yyVAL.val = EqualStr } case 1421: yyDollar = yyS[yypt-1 : yypt+1] @@ -20873,51 +24082,91 @@ yydefault: } case 1422: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7271 +//line sql3.y:7193 { +<<<<<<< Updated upstream yyVAL.str = LessThanStr +======= + yyVAL.val = LessThanStr +>>>>>>> Stashed changes } case 1423: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7275 +//line sql3.y:7197 { +<<<<<<< Updated upstream yyVAL.str = GreaterThanStr +======= + yyVAL.val = GreaterThanStr +>>>>>>> Stashed changes } case 1424: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7279 +//line sql3.y:7201 { +<<<<<<< Updated upstream yyVAL.str = LessEqualStr +======= + yyVAL.val = LessEqualStr +>>>>>>> Stashed changes } case 1425: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7283 +//line sql3.y:7205 { +<<<<<<< Updated upstream yyVAL.str = GreaterEqualStr +======= + yyVAL.val = GreaterEqualStr +>>>>>>> Stashed changes } case 1426: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7287 +//line sql3.y:7209 { +<<<<<<< Updated upstream yyVAL.str = NotEqualStr +======= + yyVAL.val = NotEqualStr +>>>>>>> Stashed changes } case 1427: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7291 +//line sql3.y:7213 { +<<<<<<< Updated upstream yyVAL.str = NullSafeEqualStr } case 1428: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:7296 +======= + yyVAL.val = NullSafeEqualStr + } + case 1428: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:7218 + { + yyVAL.val = Expr(nil) + } + case 1429: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7222 +>>>>>>> Stashed changes { - yyVAL.expr = nil + yyVAL.val = yyDollar[2].val.(Expr) } +<<<<<<< Updated upstream case 1429: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7300 +======= + case 1430: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7228 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[2].expr + yyVAL.val = yyDollar[1].val.(ValTuple) } case 1430: yyDollar = yyS[yypt-1 : yypt+1] @@ -20927,28 +24176,53 @@ yydefault: } case 1431: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7310 +//line sql3.y:7232 { +<<<<<<< Updated upstream yyVAL.colTuple = yyDollar[1].subquery +======= + yyVAL.val = yyDollar[1].val.(*Subquery) +>>>>>>> Stashed changes } case 1432: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7314 +//line sql3.y:7236 { +<<<<<<< Updated upstream yyVAL.colTuple = ListArg(yyDollar[1].bytes) } case 1433: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7320 +======= + yyVAL.val = ListArg(yyDollar[1].bytes) + } + case 1433: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7242 { - yyVAL.subquery = &Subquery{Select: yyDollar[2].selStmt} + yyVAL.val = &Subquery{Select: yyDollar[2].val.(SelectStatement)} } case 1434: yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7248 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(*Subquery) + } +<<<<<<< Updated upstream + case 1434: + yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7326 +======= + case 1435: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7252 +>>>>>>> Stashed changes { - yyVAL.simpleTableExpr = yyDollar[1].subquery + yyVAL.val = yyDollar[2].val.(SimpleTableExpr) } +<<<<<<< Updated upstream case 1435: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7330 @@ -20958,32 +24232,67 @@ yydefault: case 1436: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:7335 +======= + case 1436: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:7257 +>>>>>>> Stashed changes { - yyVAL.selectExprs = nil + yyVAL.val = SelectExprs(nil) } case 1438: yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7264 + { + yyVAL.val = SelectExprs{yyDollar[1].val.(SelectExpr)} + } +<<<<<<< Updated upstream + case 1438: + yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7342 +======= + case 1439: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7268 +>>>>>>> Stashed changes { - yyVAL.selectExprs = SelectExprs{yyDollar[1].selectExpr} + yyVAL.val = append(yyDollar[1].val.(SelectExprs), yyDollar[3].val.(SelectExpr)) } +<<<<<<< Updated upstream case 1439: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7346 +======= + case 1440: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7274 +>>>>>>> Stashed changes { - yyVAL.selectExprs = append(yyDollar[1].selectExprs, yyDollar[3].selectExpr) + yyVAL.val = Exprs{yyDollar[1].val.(Expr)} } +<<<<<<< Updated upstream case 1440: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:7352 +======= + case 1441: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7278 +>>>>>>> Stashed changes { - yyVAL.exprs = Exprs{yyDollar[1].expr} + yyVAL.val = append(yyDollar[1].val.(Exprs), yyDollar[3].val.(Expr)) } +<<<<<<< Updated upstream case 1441: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7356 +======= + case 1442: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7284 +>>>>>>> Stashed changes { - yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr) + yyVAL.val = yyDollar[1].val.(Expr) } case 1442: yyDollar = yyS[yypt-1 : yypt+1] @@ -20993,44 +24302,65 @@ yydefault: } case 1443: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7366 +//line sql3.y:7288 { +<<<<<<< Updated upstream yyVAL.expr = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} +======= + yyVAL.val = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} +>>>>>>> Stashed changes } case 1444: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7370 +//line sql3.y:7292 { - yyVAL.expr = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} + yyVAL.val = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} } case 1445: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7374 +//line sql3.y:7296 { +<<<<<<< Updated upstream yyVAL.expr = yyDollar[1].boolVal +======= + yyVAL.val = yyDollar[1].val.(BoolVal) +>>>>>>> Stashed changes } case 1446: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7378 +//line sql3.y:7300 { +<<<<<<< Updated upstream yyVAL.expr = yyDollar[1].colName +======= + yyVAL.val = yyDollar[1].val.(*ColName) +>>>>>>> Stashed changes } case 1447: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7382 +//line sql3.y:7304 { +<<<<<<< Updated upstream yyVAL.expr = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} +======= + yyVAL.val = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} +>>>>>>> Stashed changes } case 1448: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7386 +//line sql3.y:7308 { +<<<<<<< Updated upstream yyVAL.expr = yyDollar[1].expr +======= + yyVAL.val = yyDollar[1].val.(Expr) +>>>>>>> Stashed changes } case 1449: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7390 +//line sql3.y:7312 { +<<<<<<< Updated upstream yyVAL.expr = yyDollar[1].subquery } case 1450: @@ -21038,89 +24368,147 @@ yydefault: //line sql.y:7394 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitAndStr, Right: yyDollar[3].expr} +======= + yyVAL.val = yyDollar[1].val.(*Subquery) + } + case 1450: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7316 + { + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: BitAndStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1451: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7398 +//line sql3.y:7320 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitOrStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: BitOrStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1452: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7402 +//line sql3.y:7324 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitXorStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: BitXorStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1453: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7406 +//line sql3.y:7328 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: PlusStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: PlusStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1454: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7410 +//line sql3.y:7332 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: MinusStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: MinusStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1455: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7414 +//line sql3.y:7336 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: MultStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: MultStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1456: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7418 +//line sql3.y:7340 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: DivStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: DivStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1457: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7422 +//line sql3.y:7344 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: IntDivStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: IntDivStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1458: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7426 +//line sql3.y:7348 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ModStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: ModStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1459: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7430 +//line sql3.y:7352 { - yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ModStr, Right: yyDollar[3].expr} + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: ModStr, Right: yyDollar[3].val.(Expr)} } case 1460: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7434 +//line sql3.y:7356 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ShiftLeftStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: ShiftLeftStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1461: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7438 +//line sql3.y:7360 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ShiftRightStr, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(Expr), Operator: ShiftRightStr, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1462: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7442 +//line sql3.y:7364 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].colName, Operator: JSONExtractOp, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(*ColName), Operator: JSONExtractOp, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1463: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7446 +//line sql3.y:7368 { +<<<<<<< Updated upstream yyVAL.expr = &BinaryExpr{Left: yyDollar[1].colName, Operator: JSONUnquoteExtractOp, Right: yyDollar[3].expr} +======= + yyVAL.val = &BinaryExpr{Left: yyDollar[1].val.(*ColName), Operator: JSONUnquoteExtractOp, Right: yyDollar[3].val.(Expr)} +>>>>>>> Stashed changes } case 1464: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:7450 +//line sql3.y:7372 { +<<<<<<< Updated upstream yyVAL.expr = &CollateExpr{Expr: yyDollar[1].expr, Collation: yyDollar[3].str} } case 1465: @@ -21128,39 +24516,67 @@ yydefault: //line sql.y:7454 { yyVAL.expr = &UnaryExpr{Operator: BinaryStr, Expr: yyDollar[2].expr} +======= + yyVAL.val = &CollateExpr{Expr: yyDollar[1].val.(Expr), Collation: yyDollar[3].val.(string)} + } + case 1465: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7376 + { + yyVAL.val = &UnaryExpr{Operator: BinaryStr, Expr: yyDollar[2].val.(Expr)} +>>>>>>> Stashed changes } case 1466: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7458 +//line sql3.y:7380 { +<<<<<<< Updated upstream yyVAL.expr = &UnaryExpr{Operator: yyDollar[1].str, Expr: yyDollar[2].expr} +======= + yyVAL.val = &UnaryExpr{Operator: yyDollar[1].val.(string), Expr: yyDollar[2].val.(Expr)} +>>>>>>> Stashed changes } case 1467: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7462 +//line sql3.y:7384 { +<<<<<<< Updated upstream if num, ok := yyDollar[2].expr.(*SQLVal); ok && num.Type == IntVal { yyVAL.expr = num +======= + if num, ok := yyDollar[2].val.(Expr).(*SQLVal); ok && num.Type == IntVal { + yyVAL.val = num } else { - yyVAL.expr = &UnaryExpr{Operator: UPlusStr, Expr: yyDollar[2].expr} + yyVAL.val = &UnaryExpr{Operator: UPlusStr, Expr: yyDollar[2].val.(Expr)} } } case 1468: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7470 +//line sql3.y:7392 { - if num, ok := yyDollar[2].expr.(*SQLVal); ok && num.Type == IntVal { + if num, ok := yyDollar[2].val.(Expr).(*SQLVal); ok && num.Type == IntVal { // Handle double negative if num.Val[0] == '-' { num.Val = num.Val[1:] - yyVAL.expr = num + yyVAL.val = num } else { - yyVAL.expr = NewIntVal(append([]byte("-"), num.Val...)) + yyVAL.val = NewIntVal(append([]byte("-"), num.Val...)) } +>>>>>>> Stashed changes } else { - yyVAL.expr = &UnaryExpr{Operator: UMinusStr, Expr: yyDollar[2].expr} + yyVAL.val = &UnaryExpr{Operator: UMinusStr, Expr: yyDollar[2].val.(Expr)} } } + case 1468: + yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream +//line sql.y:7470 +======= +//line sql3.y:7406 +>>>>>>> Stashed changes + { + yyVAL.val = &UnaryExpr{Operator: TildaStr, Expr: yyDollar[2].val.(Expr)} + } case 1469: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:7484 @@ -21169,31 +24585,55 @@ yydefault: } case 1470: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7488 +//line sql3.y:7410 { +<<<<<<< Updated upstream yyVAL.expr = &UnaryExpr{Operator: BangStr, Expr: yyDollar[2].expr} } case 1471: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7492 +======= + yyVAL.val = &UnaryExpr{Operator: BangStr, Expr: yyDollar[2].val.(Expr)} + } + case 1471: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7414 +>>>>>>> Stashed changes { // This rule prevents the usage of INTERVAL // as a function. If support is needed for that, // we'll need to revisit this. The solution // will be non-trivial because of grammar conflicts. - yyVAL.expr = &IntervalExpr{Expr: yyDollar[2].expr, Unit: yyDollar[3].colIdent.String()} + yyVAL.val = &IntervalExpr{Expr: yyDollar[2].val.(Expr), Unit: yyDollar[3].val.(ColIdent).String()} } case 1478: yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7432 + { + yyVAL.val = &FuncExpr{Name: yyDollar[1].val.(ColIdent), Distinct: yyDollar[3].val.(string) == DistinctStr, Exprs: yyDollar[4].val.(SelectExprs)} + } +<<<<<<< Updated upstream + case 1478: + yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:7512 +======= + case 1479: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7436 +>>>>>>> Stashed changes { - yyVAL.expr = &FuncExpr{Name: yyDollar[1].colIdent, Distinct: yyDollar[3].str == DistinctStr, Exprs: yyDollar[4].selectExprs} + yyVAL.val = &FuncExpr{Qualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(ColIdent), Exprs: yyDollar[5].val.(SelectExprs)} } case 1479: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7516 +======= +//line sql3.y:7444 +>>>>>>> Stashed changes { - yyVAL.expr = &FuncExpr{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].colIdent, Exprs: yyDollar[5].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].val.(SelectExprs), Distinct: yyDollar[3].val.(string) == DistinctStr, Over: yyDollar[6].val.(*Over)} } case 1480: yyDollar = yyS[yypt-6 : yypt+1] @@ -21203,30 +24643,37 @@ yydefault: } case 1481: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:7530 +//line sql3.y:7448 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].selectExprs, Distinct: yyDollar[3].str == DistinctStr, Over: yyDollar[6].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].val.(SelectExprs), Distinct: yyDollar[3].val.(string) == DistinctStr, Over: yyDollar[6].val.(*Over)} } case 1482: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7534 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= +//line sql3.y:7452 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1483: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7538 +//line sql3.y:7456 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1484: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7542 +//line sql3.y:7460 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1485: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7546 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].selectExprs, Distinct: yyDollar[3].str == DistinctStr, Over: yyDollar[6].over} @@ -21236,15 +24683,27 @@ yydefault: //line sql.y:7550 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= +//line sql3.y:7464 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].val.(SelectExprs), Distinct: yyDollar[3].val.(string) == DistinctStr, Over: yyDollar[6].val.(*Over)} + } + case 1486: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7468 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1487: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7554 +//line sql3.y:7472 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1488: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7558 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].selectExprs, Distinct: yyDollar[3].str == DistinctStr, Over: yyDollar[6].over} @@ -21254,27 +24713,39 @@ yydefault: //line sql.y:7562 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= +//line sql3.y:7476 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].val.(SelectExprs), Distinct: yyDollar[3].val.(string) == DistinctStr, Over: yyDollar[6].val.(*Over)} + } + case 1489: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7480 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1490: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7566 +//line sql3.y:7484 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1491: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7570 +//line sql3.y:7488 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1492: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7574 +//line sql3.y:7492 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1493: yyDollar = yyS[yypt-6 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7578 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].selectExprs, Distinct: yyDollar[3].str == DistinctStr, Over: yyDollar[6].over} @@ -21284,111 +24755,159 @@ yydefault: //line sql.y:7582 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= +//line sql3.y:7496 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[4].val.(SelectExprs), Distinct: yyDollar[3].val.(string) == DistinctStr, Over: yyDollar[6].val.(*Over)} + } + case 1494: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7500 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1495: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7586 +//line sql3.y:7504 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1496: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7590 +//line sql3.y:7508 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1497: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7599 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} +======= +//line sql3.y:7515 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} +>>>>>>> Stashed changes } case 1498: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7603 +//line sql3.y:7519 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} } case 1499: yyDollar = yyS[yypt-5 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7607 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{yyDollar[3].selectExpr}, Over: yyDollar[5].over} +======= +//line sql3.y:7523 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{yyDollar[3].val.(SelectExpr)}, Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1500: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7611 +//line sql3.y:7527 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1501: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7615 +//line sql3.y:7531 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{yyDollar[3].selectExpr}, Over: yyDollar[5].over} +======= + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{yyDollar[3].val.(SelectExpr)}, Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1502: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7619 +//line sql3.y:7535 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} +======= + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} +>>>>>>> Stashed changes } case 1503: yyDollar = yyS[yypt-5 : yypt+1] -//line sql.y:7623 +//line sql3.y:7539 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs, Over: yyDollar[5].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs), Over: yyDollar[5].val.(*Over)} } case 1504: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7627 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} +======= +//line sql3.y:7543 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} +>>>>>>> Stashed changes } case 1505: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7631 +//line sql3.y:7547 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} } case 1506: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7635 +//line sql3.y:7551 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} } case 1507: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7639 +//line sql3.y:7555 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].over} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Over: yyDollar[4].val.(*Over)} } case 1508: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7650 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} +======= +//line sql3.y:7564 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} +>>>>>>> Stashed changes } case 1509: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7654 +//line sql3.y:7568 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1510: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7658 +//line sql3.y:7572 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1511: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7662 +//line sql3.y:7576 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1512: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7666 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} @@ -21398,15 +24917,27 @@ yydefault: //line sql.y:7670 { yyVAL.expr = &ConvertExpr{Name: string(yyDollar[1].bytes), Expr: yyDollar[3].expr, Type: yyDollar[5].convertType} +======= +//line sql3.y:7580 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} + } + case 1513: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7584 + { + yyVAL.val = &ConvertExpr{Name: string(yyDollar[1].bytes), Expr: yyDollar[3].val.(Expr), Type: yyDollar[5].val.(*ConvertType)} +>>>>>>> Stashed changes } case 1514: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:7674 +//line sql3.y:7588 { - yyVAL.expr = &ConvertExpr{Name: string(yyDollar[1].bytes), Expr: yyDollar[3].expr, Type: yyDollar[5].convertType} + yyVAL.val = &ConvertExpr{Name: string(yyDollar[1].bytes), Expr: yyDollar[3].val.(Expr), Type: yyDollar[5].val.(*ConvertType)} } case 1515: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7678 { yyVAL.expr = &CharExpr{Exprs: yyDollar[3].selectExprs} @@ -21416,24 +24947,53 @@ yydefault: //line sql.y:7682 { yyVAL.expr = &CharExpr{Exprs: yyDollar[3].selectExprs, Type: yyDollar[5].str} +======= +//line sql3.y:7592 + { + yyVAL.val = &CharExpr{Exprs: yyDollar[3].val.(SelectExprs)} + } + case 1516: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7596 + { + yyVAL.val = &CharExpr{Exprs: yyDollar[3].val.(SelectExprs), Type: yyDollar[5].val.(string)} +>>>>>>> Stashed changes } case 1517: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:7686 +//line sql3.y:7600 { +<<<<<<< Updated upstream yyVAL.expr = &ConvertUsingExpr{Expr: yyDollar[3].expr, Type: yyDollar[5].str} +======= + yyVAL.val = &ConvertUsingExpr{Expr: yyDollar[3].val.(Expr), Type: yyDollar[5].val.(string)} +>>>>>>> Stashed changes } case 1518: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:7690 +//line sql3.y:7604 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent("LOCATE"), Exprs: []SelectExpr{&AliasedExpr{Expr: yyDollar[3].expr}, &AliasedExpr{Expr: yyDollar[5].expr}}} } case 1519: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7694 +======= + yyVAL.val = &FuncExpr{Name: NewColIdent("LOCATE"), Exprs: []SelectExpr{&AliasedExpr{Expr: yyDollar[3].val.(Expr)}, &AliasedExpr{Expr: yyDollar[5].val.(Expr)}}} + } + case 1519: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7608 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} + } + case 1520: + yyDollar = yyS[yypt-8 : yypt+1] +//line sql3.y:7612 +>>>>>>> Stashed changes + { + yyVAL.val = &SubstrExpr{Name: yyDollar[3].val.(*ColName), From: yyDollar[5].val.(Expr), To: yyDollar[7].val.(Expr)} } case 1520: yyDollar = yyS[yypt-8 : yypt+1] @@ -21443,33 +25003,53 @@ yydefault: } case 1521: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:7702 +//line sql3.y:7616 { - yyVAL.expr = &SubstrExpr{Name: yyDollar[3].colName, From: yyDollar[5].expr, To: yyDollar[7].expr} + yyVAL.val = &SubstrExpr{Name: yyDollar[3].val.(*ColName), From: yyDollar[5].val.(Expr), To: yyDollar[7].val.(Expr)} } case 1522: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:7706 +//line sql3.y:7620 { +<<<<<<< Updated upstream yyVAL.expr = &SubstrExpr{StrVal: NewStrVal(yyDollar[3].bytes), From: yyDollar[5].expr, To: yyDollar[7].expr} +======= + yyVAL.val = &SubstrExpr{StrVal: NewStrVal(yyDollar[3].bytes), From: yyDollar[5].val.(Expr), To: yyDollar[7].val.(Expr)} +>>>>>>> Stashed changes } case 1523: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:7710 +//line sql3.y:7624 { - yyVAL.expr = &SubstrExpr{StrVal: NewStrVal(yyDollar[3].bytes), From: yyDollar[5].expr, To: yyDollar[7].expr} + yyVAL.val = &SubstrExpr{StrVal: NewStrVal(yyDollar[3].bytes), From: yyDollar[5].val.(Expr), To: yyDollar[7].val.(Expr)} } case 1524: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7714 +======= +//line sql3.y:7628 { - yyVAL.expr = &TrimExpr{Pattern: NewStrVal([]byte(" ")), Str: yyDollar[3].expr, Dir: Both} + yyVAL.val = &TrimExpr{Pattern: NewStrVal([]byte(" ")), Str: yyDollar[3].val.(Expr), Dir: Both} } case 1525: yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7632 +>>>>>>> Stashed changes + { + yyVAL.val = &TrimExpr{Pattern: yyDollar[3].val.(Expr), Str: yyDollar[5].val.(Expr), Dir: Both} + } +<<<<<<< Updated upstream + case 1525: + yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:7718 +======= + case 1526: + yyDollar = yyS[yypt-7 : yypt+1] +//line sql3.y:7636 +>>>>>>> Stashed changes { - yyVAL.expr = &TrimExpr{Pattern: yyDollar[3].expr, Str: yyDollar[5].expr, Dir: Both} + yyVAL.val = &TrimExpr{Pattern: yyDollar[4].val.(Expr), Str: yyDollar[6].val.(Expr), Dir: Leading} } case 1526: yyDollar = yyS[yypt-7 : yypt+1] @@ -21479,39 +25059,75 @@ yydefault: } case 1527: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:7726 +//line sql3.y:7640 { +<<<<<<< Updated upstream yyVAL.expr = &TrimExpr{Pattern: yyDollar[4].expr, Str: yyDollar[6].expr, Dir: Trailing} +======= + yyVAL.val = &TrimExpr{Pattern: yyDollar[4].val.(Expr), Str: yyDollar[6].val.(Expr), Dir: Trailing} +>>>>>>> Stashed changes } case 1528: yyDollar = yyS[yypt-7 : yypt+1] -//line sql.y:7730 +//line sql3.y:7644 { +<<<<<<< Updated upstream yyVAL.expr = &TrimExpr{Pattern: yyDollar[4].expr, Str: yyDollar[6].expr, Dir: Both} } case 1529: yyDollar = yyS[yypt-9 : yypt+1] //line sql.y:7734 +======= + yyVAL.val = &TrimExpr{Pattern: yyDollar[4].val.(Expr), Str: yyDollar[6].val.(Expr), Dir: Both} + } + case 1529: + yyDollar = yyS[yypt-9 : yypt+1] +//line sql3.y:7648 + { + yyVAL.val = &MatchExpr{Columns: yyDollar[3].val.(SelectExprs), Expr: yyDollar[7].val.(Expr), Option: yyDollar[8].val.(string)} + } + case 1530: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7652 +>>>>>>> Stashed changes { - yyVAL.expr = &MatchExpr{Columns: yyDollar[3].selectExprs, Expr: yyDollar[7].expr, Option: yyDollar[8].str} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } +<<<<<<< Updated upstream case 1530: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7738 +======= + case 1531: + yyDollar = yyS[yypt-7 : yypt+1] +//line sql3.y:7656 +>>>>>>> Stashed changes { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &GroupConcatExpr{Distinct: yyDollar[3].val.(string), Exprs: yyDollar[4].val.(SelectExprs), OrderBy: yyDollar[5].val.(OrderBy), Separator: yyDollar[6].val.(Separator)} } +<<<<<<< Updated upstream case 1531: yyDollar = yyS[yypt-7 : yypt+1] //line sql.y:7742 +======= + case 1532: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:7660 +>>>>>>> Stashed changes { - yyVAL.expr = &GroupConcatExpr{Distinct: yyDollar[3].str, Exprs: yyDollar[4].selectExprs, OrderBy: yyDollar[5].orderBy, Separator: yyDollar[6].separator} + yyVAL.val = &CaseExpr{Expr: yyDollar[2].val.(Expr), Whens: yyDollar[3].val.([]*When), Else: yyDollar[4].val.(Expr)} } +<<<<<<< Updated upstream case 1532: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:7746 +======= + case 1533: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7664 +>>>>>>> Stashed changes { - yyVAL.expr = &CaseExpr{Expr: yyDollar[2].expr, Whens: yyDollar[3].whens, Else: yyDollar[4].expr} + yyVAL.val = &ValuesFuncExpr{Name: yyDollar[3].val.(*ColName)} } case 1533: yyDollar = yyS[yypt-4 : yypt+1] @@ -21521,20 +25137,29 @@ yydefault: } case 1534: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7754 +//line sql3.y:7668 { +<<<<<<< Updated upstream yyVAL.expr = &ValuesFuncExpr{Name: NewColName(string(yyDollar[3].bytes))} } case 1535: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7759 +======= + yyVAL.val = &ValuesFuncExpr{Name: NewColName(string(yyDollar[3].bytes))} + } + case 1535: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7673 +>>>>>>> Stashed changes { - yyVAL.expr = &ValuesFuncExpr{Name: NewColName(string(yyDollar[3].bytes))} + yyVAL.val = &ValuesFuncExpr{Name: NewColName(string(yyDollar[3].bytes))} } case 1536: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7763 +//line sql3.y:7677 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} } case 1537: @@ -21542,24 +25167,43 @@ yydefault: //line sql.y:7774 { yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} +======= + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} + } + case 1537: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7686 + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} +>>>>>>> Stashed changes } case 1538: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7778 +//line sql3.y:7690 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} } case 1539: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7782 +//line sql3.y:7694 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} } case 1540: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7787 +======= +//line sql3.y:7699 { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = yyDollar[1].val.(Expr) + } + case 1541: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7703 +>>>>>>> Stashed changes + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1541: yyDollar = yyS[yypt-2 : yypt+1] @@ -21569,26 +25213,33 @@ yydefault: } case 1542: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7795 +//line sql3.y:7707 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].expr}}} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1543: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7799 +//line sql3.y:7711 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].expr}}} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1544: yyDollar = yyS[yypt-8 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7803 { yyVAL.expr = &TimestampFuncExpr{Name: string("timestampadd"), Unit: string(yyDollar[3].bytes), Expr1: yyDollar[5].expr, Expr2: yyDollar[7].expr} +======= +//line sql3.y:7715 + { + yyVAL.val = &TimestampFuncExpr{Name: string("timestampadd"), Unit: string(yyDollar[3].bytes), Expr1: yyDollar[5].val.(Expr), Expr2: yyDollar[7].val.(Expr)} +>>>>>>> Stashed changes } case 1545: yyDollar = yyS[yypt-8 : yypt+1] -//line sql.y:7807 +//line sql3.y:7719 { +<<<<<<< Updated upstream yyVAL.expr = &TimestampFuncExpr{Name: string("timestampdiff"), Unit: string(yyDollar[3].bytes), Expr1: yyDollar[5].expr, Expr2: yyDollar[7].expr} } case 1546: @@ -21596,24 +25247,53 @@ yydefault: //line sql.y:7811 { yyVAL.expr = &ExtractFuncExpr{Name: string(yyDollar[1].bytes), Unit: string(yyDollar[3].bytes), Expr: yyDollar[5].expr} +======= + yyVAL.val = &TimestampFuncExpr{Name: string("timestampdiff"), Unit: string(yyDollar[3].bytes), Expr1: yyDollar[5].val.(Expr), Expr2: yyDollar[7].val.(Expr)} + } + case 1546: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:7723 + { + yyVAL.val = &ExtractFuncExpr{Name: string(yyDollar[1].bytes), Unit: string(yyDollar[3].bytes), Expr: yyDollar[5].val.(Expr)} +>>>>>>> Stashed changes } case 1547: yyDollar = yyS[yypt-6 : yypt+1] -//line sql.y:7815 +//line sql3.y:7727 { +<<<<<<< Updated upstream yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: NewStrVal(yyDollar[3].bytes)}, &AliasedExpr{Expr: yyDollar[5].expr}}} } case 1548: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7823 +======= + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: NewStrVal(yyDollar[3].bytes)}, &AliasedExpr{Expr: yyDollar[5].val.(Expr)}}} + } + case 1548: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7735 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes))} + } + case 1549: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7739 +>>>>>>> Stashed changes + { + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: NewIntVal(yyDollar[3].bytes)}}} } +<<<<<<< Updated upstream case 1549: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7827 +======= + case 1550: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:7743 +>>>>>>> Stashed changes { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: NewIntVal(yyDollar[3].bytes)}}} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1550: yyDollar = yyS[yypt-2 : yypt+1] @@ -21623,27 +25303,43 @@ yydefault: } case 1551: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7835 +//line sql3.y:7747 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].expr}}} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1552: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:7839 +//line sql3.y:7751 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].expr}}} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: SelectExprs{&AliasedExpr{Expr: yyDollar[2].val.(Expr)}}} } case 1555: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7852 +======= +//line sql3.y:7764 + { + yyVAL.val = NewIntVal([]byte("0")) + } + case 1556: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7768 +>>>>>>> Stashed changes { - yyVAL.expr = NewIntVal([]byte("0")) + yyVAL.val = NewIntVal(yyDollar[2].bytes) } +<<<<<<< Updated upstream case 1556: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7856 +======= + case 1557: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7776 +>>>>>>> Stashed changes { - yyVAL.expr = NewIntVal(yyDollar[2].bytes) + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1557: yyDollar = yyS[yypt-4 : yypt+1] @@ -21653,63 +25349,97 @@ yydefault: } case 1558: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7870 +//line sql3.y:7780 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1559: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7874 +//line sql3.y:7784 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1560: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7878 +//line sql3.y:7788 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1561: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7882 +//line sql3.y:7792 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1562: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:7886 +//line sql3.y:7796 { - yyVAL.expr = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].selectExprs} + yyVAL.val = &FuncExpr{Name: NewColIdent(string(yyDollar[1].bytes)), Exprs: yyDollar[3].val.(SelectExprs)} } case 1563: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7892 +======= +//line sql3.y:7802 { - yyVAL.str = "" + yyVAL.val = "" + } + case 1564: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7806 +>>>>>>> Stashed changes + { + yyVAL.val = BooleanModeStr } +<<<<<<< Updated upstream case 1564: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7896 +======= + case 1565: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:7810 +>>>>>>> Stashed changes { - yyVAL.str = BooleanModeStr + yyVAL.val = NaturalLanguageModeStr } +<<<<<<< Updated upstream case 1565: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:7900 +======= + case 1566: + yyDollar = yyS[yypt-7 : yypt+1] +//line sql3.y:7814 +>>>>>>> Stashed changes { - yyVAL.str = NaturalLanguageModeStr + yyVAL.val = NaturalLanguageModeWithQueryExpansionStr } +<<<<<<< Updated upstream case 1566: yyDollar = yyS[yypt-7 : yypt+1] //line sql.y:7904 +======= + case 1567: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:7818 +>>>>>>> Stashed changes { - yyVAL.str = NaturalLanguageModeWithQueryExpansionStr + yyVAL.val = QueryExpansionStr } +<<<<<<< Updated upstream case 1567: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:7908 +======= + case 1568: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:7824 +>>>>>>> Stashed changes { - yyVAL.str = QueryExpansionStr + yyVAL.val = string(yyDollar[1].bytes) } case 1568: yyDollar = yyS[yypt-1 : yypt+1] @@ -21719,273 +25449,449 @@ yydefault: } case 1569: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7918 +//line sql3.y:7828 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 1570: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7922 +//line sql3.y:7832 { - yyVAL.str = string(yyDollar[1].bytes) + yyVAL.val = string(yyDollar[1].bytes) } case 1571: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:7928 { yyVAL.str = Armscii8Str +======= +//line sql3.y:7838 + { + yyVAL.val = Armscii8Str +>>>>>>> Stashed changes } case 1572: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7932 +//line sql3.y:7842 { +<<<<<<< Updated upstream yyVAL.str = AsciiStr +======= + yyVAL.val = AsciiStr +>>>>>>> Stashed changes } case 1573: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7936 +//line sql3.y:7846 { +<<<<<<< Updated upstream yyVAL.str = Big5Str +======= + yyVAL.val = Big5Str +>>>>>>> Stashed changes } case 1574: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7940 +//line sql3.y:7850 { +<<<<<<< Updated upstream yyVAL.str = UBinaryStr +======= + yyVAL.val = UBinaryStr +>>>>>>> Stashed changes } case 1575: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7944 +//line sql3.y:7854 { +<<<<<<< Updated upstream yyVAL.str = Cp1250Str +======= + yyVAL.val = Cp1250Str +>>>>>>> Stashed changes } case 1576: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7948 +//line sql3.y:7858 { +<<<<<<< Updated upstream yyVAL.str = Cp1251Str +======= + yyVAL.val = Cp1251Str +>>>>>>> Stashed changes } case 1577: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7952 +//line sql3.y:7862 { +<<<<<<< Updated upstream yyVAL.str = Cp1256Str +======= + yyVAL.val = Cp1256Str +>>>>>>> Stashed changes } case 1578: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7956 +//line sql3.y:7866 { +<<<<<<< Updated upstream yyVAL.str = Cp1257Str +======= + yyVAL.val = Cp1257Str +>>>>>>> Stashed changes } case 1579: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7960 +//line sql3.y:7870 { +<<<<<<< Updated upstream yyVAL.str = Cp850Str +======= + yyVAL.val = Cp850Str +>>>>>>> Stashed changes } case 1580: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7964 +//line sql3.y:7874 { +<<<<<<< Updated upstream yyVAL.str = Cp852Str +======= + yyVAL.val = Cp852Str +>>>>>>> Stashed changes } case 1581: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7968 +//line sql3.y:7878 { +<<<<<<< Updated upstream yyVAL.str = Cp866Str +======= + yyVAL.val = Cp866Str +>>>>>>> Stashed changes } case 1582: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7972 +//line sql3.y:7882 { +<<<<<<< Updated upstream yyVAL.str = Cp932Str +======= + yyVAL.val = Cp932Str +>>>>>>> Stashed changes } case 1583: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7976 +//line sql3.y:7886 { +<<<<<<< Updated upstream yyVAL.str = Dec8Str +======= + yyVAL.val = Dec8Str +>>>>>>> Stashed changes } case 1584: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7980 +//line sql3.y:7890 { +<<<<<<< Updated upstream yyVAL.str = EucjpmsStr +======= + yyVAL.val = EucjpmsStr +>>>>>>> Stashed changes } case 1585: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7984 +//line sql3.y:7894 { +<<<<<<< Updated upstream yyVAL.str = EuckrStr +======= + yyVAL.val = EuckrStr +>>>>>>> Stashed changes } case 1586: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7988 +//line sql3.y:7898 { +<<<<<<< Updated upstream yyVAL.str = Gb18030Str +======= + yyVAL.val = Gb18030Str +>>>>>>> Stashed changes } case 1587: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7992 +//line sql3.y:7902 { +<<<<<<< Updated upstream yyVAL.str = Gb2312Str +======= + yyVAL.val = Gb2312Str +>>>>>>> Stashed changes } case 1588: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:7996 +//line sql3.y:7906 { +<<<<<<< Updated upstream yyVAL.str = GbkStr +======= + yyVAL.val = GbkStr +>>>>>>> Stashed changes } case 1589: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8000 +//line sql3.y:7910 { +<<<<<<< Updated upstream yyVAL.str = Geostd8Str +======= + yyVAL.val = Geostd8Str +>>>>>>> Stashed changes } case 1590: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8004 +//line sql3.y:7914 { +<<<<<<< Updated upstream yyVAL.str = GreekStr +======= + yyVAL.val = GreekStr +>>>>>>> Stashed changes } case 1591: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8008 +//line sql3.y:7918 { +<<<<<<< Updated upstream yyVAL.str = HebrewStr +======= + yyVAL.val = HebrewStr +>>>>>>> Stashed changes } case 1592: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8012 +//line sql3.y:7922 { +<<<<<<< Updated upstream yyVAL.str = Hp8Str +======= + yyVAL.val = Hp8Str +>>>>>>> Stashed changes } case 1593: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8016 +//line sql3.y:7926 { +<<<<<<< Updated upstream yyVAL.str = Keybcs2Str +======= + yyVAL.val = Keybcs2Str +>>>>>>> Stashed changes } case 1594: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8020 +//line sql3.y:7930 { +<<<<<<< Updated upstream yyVAL.str = Koi8rStr +======= + yyVAL.val = Koi8rStr +>>>>>>> Stashed changes } case 1595: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8024 +//line sql3.y:7934 { +<<<<<<< Updated upstream yyVAL.str = Koi8uStr +======= + yyVAL.val = Koi8uStr +>>>>>>> Stashed changes } case 1596: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8028 +//line sql3.y:7938 { +<<<<<<< Updated upstream yyVAL.str = Latin1Str +======= + yyVAL.val = Latin1Str +>>>>>>> Stashed changes } case 1597: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8032 +//line sql3.y:7942 { +<<<<<<< Updated upstream yyVAL.str = Latin2Str +======= + yyVAL.val = Latin2Str +>>>>>>> Stashed changes } case 1598: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8036 +//line sql3.y:7946 { +<<<<<<< Updated upstream yyVAL.str = Latin5Str +======= + yyVAL.val = Latin5Str +>>>>>>> Stashed changes } case 1599: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8040 +//line sql3.y:7950 { +<<<<<<< Updated upstream yyVAL.str = Latin7Str +======= + yyVAL.val = Latin7Str +>>>>>>> Stashed changes } case 1600: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8044 +//line sql3.y:7954 { +<<<<<<< Updated upstream yyVAL.str = MacceStr +======= + yyVAL.val = MacceStr +>>>>>>> Stashed changes } case 1601: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8048 +//line sql3.y:7958 { +<<<<<<< Updated upstream yyVAL.str = MacromanStr +======= + yyVAL.val = MacromanStr +>>>>>>> Stashed changes } case 1602: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8052 +//line sql3.y:7962 { +<<<<<<< Updated upstream yyVAL.str = SjisStr +======= + yyVAL.val = SjisStr +>>>>>>> Stashed changes } case 1603: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8056 +//line sql3.y:7966 { +<<<<<<< Updated upstream yyVAL.str = Swe7Str +======= + yyVAL.val = Swe7Str +>>>>>>> Stashed changes } case 1604: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8060 +//line sql3.y:7970 { +<<<<<<< Updated upstream yyVAL.str = Tis620Str +======= + yyVAL.val = Tis620Str +>>>>>>> Stashed changes } case 1605: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8064 +//line sql3.y:7974 { +<<<<<<< Updated upstream yyVAL.str = Ucs2Str +======= + yyVAL.val = Ucs2Str +>>>>>>> Stashed changes } case 1606: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8068 +//line sql3.y:7978 { +<<<<<<< Updated upstream yyVAL.str = UjisStr +======= + yyVAL.val = UjisStr +>>>>>>> Stashed changes } case 1607: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8072 +//line sql3.y:7982 { +<<<<<<< Updated upstream yyVAL.str = Utf16Str +======= + yyVAL.val = Utf16Str +>>>>>>> Stashed changes } case 1608: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8076 +//line sql3.y:7986 { +<<<<<<< Updated upstream yyVAL.str = Utf16leStr +======= + yyVAL.val = Utf16leStr +>>>>>>> Stashed changes } case 1609: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8080 +//line sql3.y:7990 { +<<<<<<< Updated upstream yyVAL.str = Utf32Str +======= + yyVAL.val = Utf32Str +>>>>>>> Stashed changes } case 1610: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8084 +//line sql3.y:7994 { +<<<<<<< Updated upstream yyVAL.str = Utf8mb3Str +======= + yyVAL.val = Utf8mb3Str +>>>>>>> Stashed changes } case 1611: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8088 +//line sql3.y:7998 { - yyVAL.str = Utf8mb3Str + yyVAL.val = Utf8mb3Str } case 1612: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8092 +//line sql3.y:8002 { +<<<<<<< Updated upstream yyVAL.str = Utf8mb4Str } case 1613: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8098 +======= + yyVAL.val = Utf8mb4Str + } + case 1613: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8008 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} + } + case 1614: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8012 +>>>>>>> Stashed changes + { + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal), Charset: yyDollar[3].val.(string), Operator: CharacterSetStr} } case 1614: yyDollar = yyS[yypt-3 : yypt+1] @@ -21995,27 +25901,49 @@ yydefault: } case 1615: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8106 +//line sql3.y:8016 { +<<<<<<< Updated upstream yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal, Charset: string(yyDollar[3].bytes)} +======= + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal), Charset: string(yyDollar[3].bytes)} +>>>>>>> Stashed changes } case 1616: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8110 +//line sql3.y:8020 { +<<<<<<< Updated upstream yyVAL.convertType = &ConvertType{Type: "CHAR", Length: yyDollar[2].sqlVal, Charset: yyDollar[3].str, Operator: CharacterSetStr} +======= + yyVAL.val = &ConvertType{Type: "CHAR", Length: yyDollar[2].val.(*SQLVal), Charset: yyDollar[3].val.(string), Operator: CharacterSetStr} +>>>>>>> Stashed changes } case 1617: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8114 +//line sql3.y:8024 { +<<<<<<< Updated upstream yyVAL.convertType = &ConvertType{Type: "CHAR", Length: yyDollar[2].sqlVal, Charset: string(yyDollar[3].bytes)} } case 1618: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8118 +======= + yyVAL.val = &ConvertType{Type: "CHAR", Length: yyDollar[2].val.(*SQLVal), Charset: string(yyDollar[3].bytes)} + } + case 1618: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8028 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} + } + case 1619: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8032 +>>>>>>> Stashed changes + { + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} } case 1619: yyDollar = yyS[yypt-2 : yypt+1] @@ -22025,8 +25953,9 @@ yydefault: } case 1620: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:8126 +//line sql3.y:8036 { +<<<<<<< Updated upstream yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} yyVAL.convertType.Length = yyDollar[2].LengthScaleOption.Length yyVAL.convertType.Scale = yyDollar[2].LengthScaleOption.Scale @@ -22040,33 +25969,64 @@ yydefault: case 1622: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8136 +======= + ct := &ConvertType{Type: string(yyDollar[1].bytes)} + ct.Length = yyDollar[2].val.(LengthScaleOption).Length + ct.Scale = yyDollar[2].val.(LengthScaleOption).Scale + yyVAL.val = ct + } + case 1621: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8043 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} + } + case 1622: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8047 +>>>>>>> Stashed changes + { + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1623: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8140 +======= +//line sql3.y:8051 +>>>>>>> Stashed changes { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1624: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8144 +//line sql3.y:8055 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1625: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8148 +//line sql3.y:8059 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1626: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8152 +======= +//line sql3.y:8063 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} + } + case 1627: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8067 +>>>>>>> Stashed changes + { + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } +<<<<<<< Updated upstream case 1627: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8156 @@ -22076,13 +26036,19 @@ yydefault: case 1628: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8160 +======= + case 1628: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8071 +>>>>>>> Stashed changes { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1629: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:8164 +//line sql3.y:8075 { +<<<<<<< Updated upstream yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].sqlVal} } case 1630: @@ -22094,80 +26060,159 @@ yydefault: case 1631: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8172 +======= + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].val.(*SQLVal)} + } + case 1630: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8079 { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} + } + case 1631: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8083 +>>>>>>> Stashed changes + { + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1632: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8176 +======= +//line sql3.y:8087 +>>>>>>> Stashed changes { - yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} + yyVAL.val = &ConvertType{Type: string(yyDollar[1].bytes)} } case 1633: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8182 +======= +//line sql3.y:8093 +>>>>>>> Stashed changes { yyVAL.bytes = yyDollar[1].bytes } case 1634: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8186 +//line sql3.y:8097 { yyVAL.bytes = yyDollar[1].bytes } case 1635: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8191 +======= +//line sql3.y:8102 + { + yyVAL.val = Expr(nil) + } + case 1636: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8106 +>>>>>>> Stashed changes { - yyVAL.expr = nil + yyVAL.val = yyDollar[1].val.(Expr) } +<<<<<<< Updated upstream case 1636: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8195 +======= + case 1637: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8111 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = Separator{SeparatorString: "", DefaultSeparator: true} } +<<<<<<< Updated upstream case 1637: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8200 +======= + case 1638: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8115 +>>>>>>> Stashed changes { - yyVAL.separator = Separator{SeparatorString: "", DefaultSeparator: true} + yyVAL.val = Separator{SeparatorString: string(yyDollar[2].bytes), DefaultSeparator: false} } +<<<<<<< Updated upstream case 1638: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8204 +======= + case 1639: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8121 +>>>>>>> Stashed changes { - yyVAL.separator = Separator{SeparatorString: string(yyDollar[2].bytes), DefaultSeparator: false} + yyVAL.val = []*When{yyDollar[1].val.(*When)} } +<<<<<<< Updated upstream case 1639: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8210 +======= + case 1640: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8125 +>>>>>>> Stashed changes { - yyVAL.whens = []*When{yyDollar[1].when} + yyVAL.val = append(yyDollar[1].val.([]*When), yyDollar[2].val.(*When)) } +<<<<<<< Updated upstream case 1640: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8214 +======= + case 1641: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8131 +>>>>>>> Stashed changes { - yyVAL.whens = append(yyDollar[1].whens, yyDollar[2].when) + yyVAL.val = &When{Cond: yyDollar[2].val.(Expr), Val: yyDollar[4].val.(Expr)} } +<<<<<<< Updated upstream case 1641: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:8220 +======= + case 1642: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8136 +>>>>>>> Stashed changes { - yyVAL.when = &When{Cond: yyDollar[2].expr, Val: yyDollar[4].expr} + yyVAL.val = Expr(nil) } +<<<<<<< Updated upstream case 1642: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8225 +======= + case 1643: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8140 +>>>>>>> Stashed changes { - yyVAL.expr = nil + yyVAL.val = yyDollar[2].val.(Expr) } +<<<<<<< Updated upstream case 1643: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8229 +======= + case 1644: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8146 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[2].expr + yyVAL.val = &ColName{Name: yyDollar[1].val.(ColIdent)} } case 1644: yyDollar = yyS[yypt-1 : yypt+1] @@ -22177,8 +26222,9 @@ yydefault: } case 1645: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8239 +//line sql3.y:8150 { +<<<<<<< Updated upstream yyVAL.colName = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} } case 1646: @@ -22186,84 +26232,131 @@ yydefault: //line sql.y:8243 { yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: yyDollar[3].colIdent} +======= + yyVAL.val = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} + } + case 1646: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8154 + { + yyVAL.val = &ColName{Qualifier: TableName{Name: yyDollar[1].val.(TableIdent)}, Name: yyDollar[3].val.(ColIdent)} +>>>>>>> Stashed changes } case 1647: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8247 +//line sql3.y:8158 { +<<<<<<< Updated upstream yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: NewColIdent(string(yyDollar[3].bytes))} +======= + yyVAL.val = &ColName{Qualifier: TableName{Name: yyDollar[1].val.(TableIdent)}, Name: NewColIdent(string(yyDollar[3].bytes))} +>>>>>>> Stashed changes } case 1648: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8251 +//line sql3.y:8162 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: NewColIdent(string(yyDollar[3].bytes))} + yyVAL.val = &ColName{Qualifier: TableName{Name: yyDollar[1].val.(TableIdent)}, Name: NewColIdent(string(yyDollar[3].bytes))} } case 1649: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8255 +//line sql3.y:8166 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: NewColIdent(string(yyDollar[3].bytes))} + yyVAL.val = &ColName{Qualifier: TableName{Name: yyDollar[1].val.(TableIdent)}, Name: NewColIdent(string(yyDollar[3].bytes))} } case 1650: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8259 +//line sql3.y:8170 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: NewColIdent(string(yyDollar[3].bytes))} + yyVAL.val = &ColName{Qualifier: TableName{Name: yyDollar[1].val.(TableIdent)}, Name: NewColIdent(string(yyDollar[3].bytes))} } case 1651: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8263 +//line sql3.y:8174 { +<<<<<<< Updated upstream yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].colIdent} +======= + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].val.(ColIdent)} +>>>>>>> Stashed changes } case 1652: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8267 +//line sql3.y:8178 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].colIdent} + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].val.(ColIdent)} } case 1653: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8271 +//line sql3.y:8182 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].colIdent} + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].val.(ColIdent)} } case 1654: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8275 +//line sql3.y:8186 { +<<<<<<< Updated upstream yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: NewColIdent(string(yyDollar[3].bytes))} +======= + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: NewColIdent(string(yyDollar[3].bytes))} +>>>>>>> Stashed changes } case 1655: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8279 +//line sql3.y:8190 { +<<<<<<< Updated upstream yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].colIdent} +======= + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].val.(ColIdent)} +>>>>>>> Stashed changes } case 1656: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8283 +//line sql3.y:8194 { - yyVAL.colName = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].colIdent} + yyVAL.val = &ColName{Qualifier: TableName{Name: NewTableIdent(string(yyDollar[1].bytes))}, Name: yyDollar[3].val.(ColIdent)} } case 1657: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8287 +======= +//line sql3.y:8198 { - yyVAL.colName = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} + yyVAL.val = &ColName{Name: NewColIdent(string(yyDollar[1].bytes))} + } + case 1658: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:8202 +>>>>>>> Stashed changes + { + yyVAL.val = &ColName{Qualifier: TableName{DbQualifier: yyDollar[1].val.(TableIdent), Name: yyDollar[3].val.(TableIdent)}, Name: yyDollar[5].val.(ColIdent)} } +<<<<<<< Updated upstream case 1658: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:8291 +======= + case 1659: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8208 +>>>>>>> Stashed changes { - yyVAL.colName = &ColName{Qualifier: TableName{DbQualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent}, Name: yyDollar[5].colIdent} + yyVAL.val = NewStrVal(yyDollar[1].bytes) } +<<<<<<< Updated upstream case 1659: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8297 +======= + case 1660: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8212 +>>>>>>> Stashed changes { - yyVAL.expr = NewStrVal(yyDollar[1].bytes) + yyVAL.val = NewStrVal(yyDollar[2].bytes) } case 1660: yyDollar = yyS[yypt-2 : yypt+1] @@ -22273,63 +26366,103 @@ yydefault: } case 1661: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:8305 +//line sql3.y:8216 { - yyVAL.expr = NewStrVal(yyDollar[2].bytes) + yyVAL.val = NewStrVal(yyDollar[2].bytes) } case 1662: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:8309 +//line sql3.y:8220 { - yyVAL.expr = NewStrVal(yyDollar[2].bytes) + yyVAL.val = NewStrVal(yyDollar[2].bytes) } case 1663: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8313 { yyVAL.expr = NewHexVal(yyDollar[1].bytes) +======= +//line sql3.y:8224 + { + yyVAL.val = NewHexVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1664: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8317 +//line sql3.y:8228 { +<<<<<<< Updated upstream yyVAL.expr = NewBitVal(yyDollar[1].bytes) +======= + yyVAL.val = NewBitVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1665: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8321 +//line sql3.y:8232 { +<<<<<<< Updated upstream yyVAL.expr = NewIntVal(yyDollar[1].bytes) +======= + yyVAL.val = NewIntVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1666: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8325 +//line sql3.y:8236 { +<<<<<<< Updated upstream yyVAL.expr = NewFloatVal(yyDollar[1].bytes) +======= + yyVAL.val = NewFloatVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1667: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8329 +//line sql3.y:8240 { +<<<<<<< Updated upstream yyVAL.expr = NewHexNum(yyDollar[1].bytes) +======= + yyVAL.val = NewHexNum(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1668: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8333 +//line sql3.y:8244 { +<<<<<<< Updated upstream yyVAL.expr = NewValArg(yyDollar[1].bytes) +======= + yyVAL.val = NewValArg(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1669: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8337 +//line sql3.y:8248 { +<<<<<<< Updated upstream yyVAL.expr = &NullVal{} } case 1670: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8343 +======= + yyVAL.val = &NullVal{} + } + case 1670: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8254 + { + yyVAL.val = NewIntVal([]byte("1")) + } + case 1671: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8258 +>>>>>>> Stashed changes { - yyVAL.expr = NewIntVal([]byte("1")) + yyVAL.val = NewIntVal(yyDollar[1].bytes) } case 1671: yyDollar = yyS[yypt-2 : yypt+1] @@ -22339,88 +26472,175 @@ yydefault: } case 1672: yyDollar = yyS[yypt-2 : yypt+1] -//line sql.y:8351 +//line sql3.y:8262 { +<<<<<<< Updated upstream yyVAL.expr = NewValArg(yyDollar[1].bytes) } case 1673: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8356 +======= + yyVAL.val = NewValArg(yyDollar[1].bytes) + } + case 1673: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8267 + { + yyVAL.val = Exprs(nil) + } + case 1674: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8271 +>>>>>>> Stashed changes { - yyVAL.exprs = nil + yyVAL.val = yyDollar[3].val.(Exprs) } +<<<<<<< Updated upstream case 1674: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8360 +======= + case 1675: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8277 +>>>>>>> Stashed changes { - yyVAL.exprs = yyDollar[3].exprs + yyVAL.val = Exprs{yyDollar[1].val.(Expr)} } +<<<<<<< Updated upstream case 1675: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8366 +======= + case 1676: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8281 +>>>>>>> Stashed changes { - yyVAL.exprs = Exprs{yyDollar[1].expr} + yyVAL.val = append(yyDollar[1].val.(Exprs), yyDollar[3].val.(Expr)) } +<<<<<<< Updated upstream case 1676: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8370 +======= + case 1677: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8287 +>>>>>>> Stashed changes { - yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr) + yyVAL.val = yyDollar[1].val.(Expr) } +<<<<<<< Updated upstream case 1677: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8376 +======= + case 1678: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8292 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = Expr(nil) } +<<<<<<< Updated upstream case 1678: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8381 +======= + case 1679: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8296 +>>>>>>> Stashed changes { - yyVAL.expr = nil + yyVAL.val = yyDollar[2].val.(Expr) } +<<<<<<< Updated upstream case 1679: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8385 +======= + case 1680: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8302 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[2].expr + yyVAL.val = yyDollar[1].val.(Expr) } +<<<<<<< Updated upstream case 1680: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8391 +======= + case 1681: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8307 +>>>>>>> Stashed changes { - yyVAL.expr = yyDollar[1].expr + yyVAL.val = OrderBy(nil) } +<<<<<<< Updated upstream case 1681: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8396 +======= + case 1682: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8311 +>>>>>>> Stashed changes { - yyVAL.orderBy = nil + yyVAL.val = yyDollar[3].val.(OrderBy) } +<<<<<<< Updated upstream case 1682: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8400 +======= + case 1683: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8317 +>>>>>>> Stashed changes { - yyVAL.orderBy = yyDollar[3].orderBy + yyVAL.val = OrderBy{yyDollar[1].val.(*Order)} } +<<<<<<< Updated upstream case 1683: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8406 +======= + case 1684: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8321 +>>>>>>> Stashed changes { - yyVAL.orderBy = OrderBy{yyDollar[1].order} + yyVAL.val = append(yyDollar[1].val.(OrderBy), yyDollar[3].val.(*Order)) } +<<<<<<< Updated upstream case 1684: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8410 +======= + case 1685: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8327 +>>>>>>> Stashed changes { - yyVAL.orderBy = append(yyDollar[1].orderBy, yyDollar[3].order) + yyVAL.val = &Order{Expr: yyDollar[1].val.(Expr), Direction: yyDollar[2].val.(string)} } +<<<<<<< Updated upstream case 1685: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8416 +======= + case 1686: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8332 +>>>>>>> Stashed changes { - yyVAL.order = &Order{Expr: yyDollar[1].expr, Direction: yyDollar[2].str} + yyVAL.val = AscScr } +<<<<<<< Updated upstream case 1686: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8421 @@ -22430,26 +26650,51 @@ yydefault: case 1687: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8425 +======= + case 1687: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8336 +>>>>>>> Stashed changes { - yyVAL.str = AscScr + yyVAL.val = AscScr } case 1688: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8429 +//line sql3.y:8340 { +<<<<<<< Updated upstream yyVAL.str = DescScr } case 1689: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8434 +======= + yyVAL.val = DescScr + } + case 1689: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8345 + { + yyVAL.val = &Limit{} + } + case 1690: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8349 +>>>>>>> Stashed changes { - yyVAL.limit = nil + yyVAL.val = &Limit{Rowcount: yyDollar[2].val.(Expr)} } +<<<<<<< Updated upstream case 1690: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8438 +======= + case 1691: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8353 +>>>>>>> Stashed changes { - yyVAL.limit = &Limit{Rowcount: yyDollar[2].expr} + yyVAL.val = &Limit{Offset: yyDollar[2].val.(Expr), Rowcount: yyDollar[4].val.(Expr)} } case 1691: yyDollar = yyS[yypt-4 : yypt+1] @@ -22459,8 +26704,9 @@ yydefault: } case 1692: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:8446 +//line sql3.y:8357 { +<<<<<<< Updated upstream yyVAL.limit = &Limit{Offset: yyDollar[4].expr, Rowcount: yyDollar[2].expr} } case 1693: @@ -22468,30 +26714,63 @@ yydefault: //line sql.y:8452 { yyVAL.expr = NewIntVal(yyDollar[1].bytes) +======= + yyVAL.val = &Limit{Offset: yyDollar[4].val.(Expr), Rowcount: yyDollar[2].val.(Expr)} + } + case 1693: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8363 + { + yyVAL.val = NewIntVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1694: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8456 +//line sql3.y:8367 { +<<<<<<< Updated upstream yyVAL.expr = NewValArg(yyDollar[1].bytes) +======= + yyVAL.val = NewValArg(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1695: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8460 +//line sql3.y:8371 { +<<<<<<< Updated upstream yyVAL.expr = yyDollar[1].colName } case 1696: yyDollar = yyS[yypt-0 : yypt+1] -//line sql.y:8465 +//line sql.y:8465 +======= + yyVAL.val = yyDollar[1].val.(*ColName) + } + case 1696: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8376 { - yyVAL.str = "" + yyVAL.val = "" + } + case 1697: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8380 +>>>>>>> Stashed changes + { + yyVAL.val = ForUpdateStr } +<<<<<<< Updated upstream case 1697: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8469 +======= + case 1698: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8384 +>>>>>>> Stashed changes { - yyVAL.str = ForUpdateStr + yyVAL.val = ForUpdateSkipLockedStr } case 1698: yyDollar = yyS[yypt-4 : yypt+1] @@ -22501,75 +26780,138 @@ yydefault: } case 1699: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:8477 +//line sql3.y:8388 { +<<<<<<< Updated upstream yyVAL.str = ShareModeStr } case 1700: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8483 +======= + yyVAL.val = ShareModeStr + } + case 1700: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8394 { - yyVAL.ins = yyDollar[1].ins + yyVAL.val = yyDollar[1].val.(*Insert) } case 1701: yyDollar = yyS[yypt-4 : yypt+1] -//line sql.y:8487 +//line sql3.y:8398 +>>>>>>> Stashed changes { - yyVAL.ins = yyDollar[1].ins + yyVAL.val = yyDollar[1].val.(*Insert) // Rows is guarenteed to be an *AliasedValues here. - rows := yyVAL.ins.Rows.(*AliasedValues) - rows.As = yyDollar[3].tableIdent - if yyDollar[4].columns != nil { - rows.Columns = yyDollar[4].columns + rows := yyVAL.val.(*Insert).Rows.(*AliasedValues) + rows.As = yyDollar[3].val.(TableIdent) + if yyDollar[4].val.(Columns) != nil { + rows.Columns = yyDollar[4].val.(Columns) } - yyVAL.ins.Rows = rows + yyVAL.val.(*Insert).Rows = rows + } +<<<<<<< Updated upstream + case 1701: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql.y:8487 +======= + case 1702: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8418 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[1].val.(*Insert) } +<<<<<<< Updated upstream case 1702: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8507 +======= + case 1703: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8422 +>>>>>>> Stashed changes { - yyVAL.ins = yyDollar[1].ins + yyDollar[3].val.(*Insert).Columns = []ColIdent{} + yyVAL.val = yyDollar[3].val.(*Insert) } +<<<<<<< Updated upstream case 1703: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8511 +======= + case 1704: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8427 +>>>>>>> Stashed changes { - yyDollar[3].ins.Columns = []ColIdent{} - yyVAL.ins = yyDollar[3].ins + yyDollar[4].val.(*Insert).Columns = yyDollar[2].val.(Columns) + yyVAL.val = yyDollar[4].val.(*Insert) } +<<<<<<< Updated upstream case 1704: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:8516 +======= + case 1705: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8434 +>>>>>>> Stashed changes { - yyDollar[4].ins.Columns = yyDollar[2].columns - yyVAL.ins = yyDollar[4].ins + yyVAL.val = &Insert{Rows: yyDollar[1].val.(SelectStatement)} } +<<<<<<< Updated upstream case 1705: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8523 +======= + case 1706: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8438 +>>>>>>> Stashed changes { - yyVAL.ins = &Insert{Rows: yyDollar[1].selStmt} + yyVAL.val = &Insert{Columns: yyDollar[2].val.(Columns), Rows: yyDollar[4].val.(SelectStatement)} } +<<<<<<< Updated upstream case 1706: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:8527 +======= + case 1707: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8442 +>>>>>>> Stashed changes { - yyVAL.ins = &Insert{Columns: yyDollar[2].columns, Rows: yyDollar[4].selStmt} + // Drop the redundant parenthesis. + yyVAL.val = &Insert{Rows: yyDollar[2].val.(SelectStatement)} } +<<<<<<< Updated upstream case 1707: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8531 +======= + case 1708: + yyDollar = yyS[yypt-6 : yypt+1] +//line sql3.y:8447 +>>>>>>> Stashed changes { // Drop the redundant parenthesis. - yyVAL.ins = &Insert{Rows: yyDollar[2].selStmt} + yyVAL.val = &Insert{Columns: yyDollar[2].val.(Columns), Rows: yyDollar[5].val.(SelectStatement)} } +<<<<<<< Updated upstream case 1708: yyDollar = yyS[yypt-6 : yypt+1] //line sql.y:8536 +======= + case 1709: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8454 +>>>>>>> Stashed changes { - // Drop the redundant parenthesis. - yyVAL.ins = &Insert{Columns: yyDollar[2].columns, Rows: yyDollar[5].selStmt} + yyVAL.val = &Insert{Rows: &AliasedValues{Values: yyDollar[2].val.(Values)}} } +<<<<<<< Updated upstream case 1709: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8543 @@ -22579,38 +26921,77 @@ yydefault: case 1710: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8547 +======= + case 1710: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8458 +>>>>>>> Stashed changes + { + yyVAL.val = yyDollar[2].val.(*Insert) + } + case 1713: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8467 { - yyVAL.ins = yyDollar[2].ins + yyVAL.val = Columns(nil) } +<<<<<<< Updated upstream case 1713: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8556 +======= + case 1714: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8471 +>>>>>>> Stashed changes { - yyVAL.columns = nil + yyVAL.val = yyDollar[2].val.(Columns) } +<<<<<<< Updated upstream case 1714: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8560 +======= + case 1715: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8477 +>>>>>>> Stashed changes { - yyVAL.columns = yyDollar[2].columns + yyVAL.val = Columns{yyDollar[1].val.(ColIdent)} } +<<<<<<< Updated upstream case 1715: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8566 +======= + case 1716: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8481 +>>>>>>> Stashed changes { - yyVAL.columns = Columns{yyDollar[1].colIdent} + yyVAL.val = append(yyVAL.val.(Columns), yyDollar[3].val.(ColIdent)) } case 1716: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8570 +======= +//line sql3.y:8488 +>>>>>>> Stashed changes { - yyVAL.columns = append(yyVAL.columns, yyDollar[3].colIdent) + yyVAL.val = yyDollar[3].val } +<<<<<<< Updated upstream case 1717: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8576 +======= + case 1718: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8492 +>>>>>>> Stashed changes { - yyVAL.colIdent = yyDollar[3].colIdent + yyVAL.val = yyDollar[1].val.(ColIdent) } case 1718: yyDollar = yyS[yypt-1 : yypt+1] @@ -22620,97 +27001,163 @@ yydefault: } case 1719: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8584 +//line sql3.y:8496 { +<<<<<<< Updated upstream yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) +======= + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) +>>>>>>> Stashed changes } case 1720: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8588 +//line sql3.y:8500 { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1721: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8592 +//line sql3.y:8504 { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1722: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8596 +//line sql3.y:8508 { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1723: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8601 +======= +//line sql3.y:8513 + { + yyVAL.val = AssignmentExprs(nil) + } + case 1724: + yyDollar = yyS[yypt-5 : yypt+1] +//line sql3.y:8517 +>>>>>>> Stashed changes { - yyVAL.assignExprs = nil + yyVAL.val = yyDollar[5].val.(AssignmentExprs) } +<<<<<<< Updated upstream case 1724: yyDollar = yyS[yypt-5 : yypt+1] //line sql.y:8605 +======= + case 1725: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8523 +>>>>>>> Stashed changes { - yyVAL.assignExprs = yyDollar[5].assignExprs + yyVAL.val = Values{yyDollar[1].val.(ValTuple)} } +<<<<<<< Updated upstream case 1725: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8611 +======= + case 1726: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8527 +>>>>>>> Stashed changes { - yyVAL.values = Values{yyDollar[1].valTuple} + yyVAL.val = append(yyDollar[1].val.(Values), yyDollar[3].val.(ValTuple)) } +<<<<<<< Updated upstream case 1726: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8615 +======= + case 1727: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8533 +>>>>>>> Stashed changes { - yyVAL.values = append(yyDollar[1].values, yyDollar[3].valTuple) + yyVAL.val = yyDollar[2].val.(ValTuple) } +<<<<<<< Updated upstream case 1727: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8621 +======= + case 1728: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8537 +>>>>>>> Stashed changes { - yyVAL.valTuple = yyDollar[2].valTuple + yyVAL.val = ValTuple{} } case 1728: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8625 +======= +//line sql3.y:8543 +>>>>>>> Stashed changes { - yyVAL.valTuple = ValTuple{} + yyVAL.val = ValTuple(yyDollar[2].val.(Exprs)) } +<<<<<<< Updated upstream case 1729: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8631 +======= + case 1730: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8549 +>>>>>>> Stashed changes { - yyVAL.valTuple = ValTuple(yyDollar[2].exprs) + if len(yyDollar[1].val.(ValTuple)) == 1 { + yyVAL.val = &ParenExpr{yyDollar[1].val.(ValTuple)[0]} + } else { + yyVAL.val = yyDollar[1].val.(ValTuple) + } } case 1730: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8637 +======= +//line sql3.y:8559 +>>>>>>> Stashed changes { - if len(yyDollar[1].valTuple) == 1 { - yyVAL.expr = &ParenExpr{yyDollar[1].valTuple[0]} - } else { - yyVAL.expr = yyDollar[1].valTuple - } + yyVAL.val = AssignmentExprs{yyDollar[1].val.(*AssignmentExpr)} } +<<<<<<< Updated upstream case 1731: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8647 +======= + case 1732: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8563 +>>>>>>> Stashed changes { - yyVAL.assignExprs = AssignmentExprs{yyDollar[1].assignExpr} + yyVAL.val = append(yyDollar[1].val.(AssignmentExprs), yyDollar[3].val.(*AssignmentExpr)) } case 1732: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8651 +======= +//line sql3.y:8569 +>>>>>>> Stashed changes { - yyVAL.assignExprs = append(yyDollar[1].assignExprs, yyDollar[3].assignExpr) + yyVAL.val = &AssignmentExpr{Name: yyDollar[1].val.(*ColName), Expr: yyDollar[3].val.(Expr)} } case 1733: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8657 +======= +//line sql3.y:8572 +>>>>>>> Stashed changes { - yyVAL.assignExpr = &AssignmentExpr{Name: yyDollar[1].colName, Expr: yyDollar[3].expr} + yyVAL.val = &AssignmentExpr{Name: &ColName{Name: NewColIdent(string(yyDollar[1].bytes))}, Expr: yyDollar[3].val.(Expr)} } case 1734: yyDollar = yyS[yypt-3 : yypt+1] @@ -22720,22 +27167,33 @@ yydefault: } case 1735: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8664 +//line sql3.y:8576 { - yyVAL.assignExpr = &AssignmentExpr{Name: &ColName{Name: NewColIdent(string(yyDollar[1].bytes))}, Expr: yyDollar[3].expr} + yyVAL.val = &AssignmentExpr{Name: &ColName{Name: NewColIdent(string(yyDollar[1].bytes))}, Expr: yyDollar[3].val.(Expr)} } case 1736: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8668 +//line sql3.y:8580 { - yyVAL.assignExpr = &AssignmentExpr{Name: &ColName{Name: NewColIdent(string(yyDollar[1].bytes))}, Expr: yyDollar[3].expr} + yyVAL.val = &AssignmentExpr{Name: &ColName{Name: NewColIdent(string(yyDollar[1].bytes))}, Expr: yyDollar[3].val.(Expr)} } case 1737: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8674 +======= +//line sql3.y:8586 + { + yyVAL.val = SetVarExprs{yyDollar[1].val.(*SetVarExpr)} + } + case 1738: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8590 +>>>>>>> Stashed changes { - yyVAL.setVarExprs = SetVarExprs{yyDollar[1].setVarExpr} + yyVAL.val = append(yyDollar[1].val.(SetVarExprs), yyDollar[3].val.(*SetVarExpr)) } +<<<<<<< Updated upstream case 1738: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8678 @@ -22745,15 +27203,35 @@ yydefault: case 1739: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8684 +======= + case 1739: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8596 +>>>>>>> Stashed changes { - colName, scope, _, err := VarScopeForColName(yyDollar[1].setVarExpr.Name) + colName, scope, _, err := VarScopeForColName(yyDollar[1].val.(*SetVarExpr).Name) if err != nil { yylex.Error(err.Error()) return 1 } - yyDollar[1].setVarExpr.Name = colName - yyDollar[1].setVarExpr.Scope = scope - yyVAL.setVarExpr = yyDollar[1].setVarExpr + yyDollar[1].val.(*SetVarExpr).Name = colName + yyDollar[1].val.(*SetVarExpr).Scope = scope + yyVAL.val = yyDollar[1].val.(*SetVarExpr) + } + case 1740: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8607 + { + _, scope, _, err := VarScopeForColName(yyDollar[2].val.(*SetVarExpr).Name) + if err != nil { + yylex.Error(err.Error()) + return 1 + } else if scope != SetScope_None { + yylex.Error(fmt.Sprintf("invalid system variable name `%s`", yyDollar[2].val.(*SetVarExpr).Name.Name.val)) + return 1 + } + yyDollar[2].val.(*SetVarExpr).Scope = yyDollar[1].val.(SetScope) + yyVAL.val = yyDollar[2].val.(*SetVarExpr) } case 1740: yyDollar = yyS[yypt-2 : yypt+1] @@ -22772,24 +27250,38 @@ yydefault: } case 1741: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8708 +======= +//line sql3.y:8620 +>>>>>>> Stashed changes { - _, scope, _, err := VarScopeForColName(yyDollar[2].setVarExpr.Name) + _, scope, _, err := VarScopeForColName(yyDollar[2].val.(*SetVarExpr).Name) if err != nil { yylex.Error(err.Error()) return 1 } else if scope != SetScope_None { - yylex.Error(fmt.Sprintf("invalid system variable name `%s`", yyDollar[2].setVarExpr.Name.Name.val)) + yylex.Error(fmt.Sprintf("invalid system variable name `%s`", yyDollar[2].val.(*SetVarExpr).Name.Name.val)) return 1 } - yyDollar[2].setVarExpr.Scope = yyDollar[1].setScope - yyVAL.setVarExpr = yyDollar[2].setVarExpr + yyDollar[2].val.(*SetVarExpr).Scope = yyDollar[1].val.(SetScope) + yyVAL.val = yyDollar[2].val.(*SetVarExpr) } case 1742: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8721 +======= +//line sql3.y:8633 + { + yyVAL.val = &SetVarExpr{Name: NewColName(string(yyDollar[1].bytes)), Expr: yyDollar[2].val.(Expr), Scope: SetScope_Session} + } + case 1743: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8639 +>>>>>>> Stashed changes { - yyVAL.setVarExpr = &SetVarExpr{Name: NewColName(string(yyDollar[1].bytes)), Expr: yyDollar[2].expr, Scope: SetScope_Session} + yyVAL.val = SetScope_Global } case 1743: yyDollar = yyS[yypt-1 : yypt+1] @@ -22799,26 +27291,39 @@ yydefault: } case 1744: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8731 +//line sql3.y:8643 { +<<<<<<< Updated upstream yyVAL.setScope = SetScope_Session } case 1745: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8737 +======= + yyVAL.val = SetScope_Session + } + case 1745: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8649 +>>>>>>> Stashed changes { - yyVAL.setScope = SetScope_Session + yyVAL.val = SetScope_Session } case 1746: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8741 +//line sql3.y:8653 { +<<<<<<< Updated upstream yyVAL.setScope = SetScope_Persist +======= + yyVAL.val = SetScope_Persist +>>>>>>> Stashed changes } case 1747: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8745 +//line sql3.y:8657 { +<<<<<<< Updated upstream yyVAL.setScope = SetScope_PersistOnly } case 1748: @@ -22826,59 +27331,105 @@ yydefault: //line sql.y:8751 { yyVAL.setVarExpr = &SetVarExpr{Name: yyDollar[1].colName, Expr: NewStrVal(yyDollar[3].bytes), Scope: SetScope_None} +======= + yyVAL.val = SetScope_PersistOnly + } + case 1748: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8663 + { + yyVAL.val = &SetVarExpr{Name: yyDollar[1].val.(*ColName), Expr: NewStrVal(yyDollar[3].bytes), Scope: SetScope_None} +>>>>>>> Stashed changes } case 1749: yyDollar = yyS[yypt-3 : yypt+1] -//line sql.y:8755 +//line sql3.y:8667 { - yyVAL.setVarExpr = &SetVarExpr{Name: yyDollar[1].colName, Expr: NewStrVal(yyDollar[3].bytes), Scope: SetScope_None} + yyVAL.val = &SetVarExpr{Name: yyDollar[1].val.(*ColName), Expr: NewStrVal(yyDollar[3].bytes), Scope: SetScope_None} } case 1750: yyDollar = yyS[yypt-4 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8759 +======= +//line sql3.y:8671 +>>>>>>> Stashed changes { // NOTE: This is a fix to allow MySQL dumps to load cleanly when they contain the following: // SET @@GLOBAL.GTID_PURGED= /*!80000 '+'*/ 'beabe64c-9dc6-11ed-8021-a0f9021e8e70:1-126'; // The full fix is for any adjacent single-quoted or double-quoted strings to be concatenated but // this fixes the most pressing case. For more details, see: https://github.com/dolthub/dolt/issues/5232 // In other places we can correctly concatenate adjacent string literals, but the special comments break it - yyVAL.setVarExpr = &SetVarExpr{Name: yyDollar[1].colName, Expr: NewStrVal([]byte(string(yyDollar[3].bytes) + string(yyDollar[4].bytes))), Scope: SetScope_None} + + yyVAL.val = &SetVarExpr{Name: yyDollar[1].val.(*ColName), Expr: NewStrVal([]byte(string(yyDollar[3].bytes) + string(yyDollar[4].bytes))), Scope: SetScope_None} } case 1751: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8768 +======= +//line sql3.y:8681 +>>>>>>> Stashed changes { - yyVAL.setVarExpr = &SetVarExpr{Name: yyDollar[1].colName, Expr: yyDollar[3].expr, Scope: SetScope_None} + yyVAL.val = &SetVarExpr{Name: yyDollar[1].val.(*ColName), Expr: yyDollar[3].val.(Expr), Scope: SetScope_None} } case 1753: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8775 +======= +//line sql3.y:8688 +>>>>>>> Stashed changes { yyVAL.bytes = []byte("charset") } case 1755: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8782 { yyVAL.expr = NewStrVal([]byte(yyDollar[1].colIdent.String())) +======= +//line sql3.y:8695 + { + yyVAL.val = NewStrVal([]byte(yyDollar[1].val.(ColIdent).String())) +>>>>>>> Stashed changes } case 1756: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8786 +//line sql3.y:8699 { +<<<<<<< Updated upstream yyVAL.expr = NewStrVal(yyDollar[1].bytes) +======= + yyVAL.val = NewStrVal(yyDollar[1].bytes) +>>>>>>> Stashed changes } case 1757: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8790 +//line sql3.y:8703 { +<<<<<<< Updated upstream yyVAL.expr = &Default{} } case 1760: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8799 +======= + yyVAL.val = &Default{} + } + case 1760: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8712 { - yyVAL.byt = 0 + yyVAL.val = 0 + } + case 1761: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8714 +>>>>>>> Stashed changes + { + yyVAL.val = 1 } case 1761: yyDollar = yyS[yypt-1 : yypt+1] @@ -22888,6 +27439,7 @@ yydefault: } case 1762: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8804 { yyVAL.byt = 0 @@ -22901,32 +27453,77 @@ yydefault: case 1764: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8809 +======= +//line sql3.y:8717 { - yyVAL.byt = 0 + yyVAL.val = 0 + } + case 1763: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8719 + { + yyVAL.val = 1 + } + case 1764: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8722 + { + yyVAL.val = 0 + } + case 1765: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8724 +>>>>>>> Stashed changes + { + yyVAL.val = 1 } +<<<<<<< Updated upstream case 1765: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8811 +======= + case 1766: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8727 +>>>>>>> Stashed changes { - yyVAL.byt = 1 + yyVAL.val = "" } +<<<<<<< Updated upstream case 1766: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8814 +======= + case 1767: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8729 +>>>>>>> Stashed changes { - yyVAL.str = "" + yyVAL.val = IgnoreStr } +<<<<<<< Updated upstream case 1767: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8816 +======= + case 1768: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8732 +>>>>>>> Stashed changes { - yyVAL.str = IgnoreStr + yyVAL.val = nil } +<<<<<<< Updated upstream case 1768: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8819 +======= + case 1769: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8734 +>>>>>>> Stashed changes { - yyVAL.sqlVal = nil + yyVAL.val = NewIntVal(yyDollar[2].bytes) } case 1769: yyDollar = yyS[yypt-3 : yypt+1] @@ -22936,12 +27533,17 @@ yydefault: } case 1770: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8823 +======= +//line sql3.y:8736 +>>>>>>> Stashed changes { - yyVAL.sqlVal = NewIntVal(yyDollar[2].bytes) + yyVAL.val = NewIntVal(yyDollar[2].bytes) } case 1771: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8826 { yyVAL.empty = struct{}{} @@ -22949,81 +27551,157 @@ yydefault: case 1772: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8828 +======= +//line sql3.y:8739 { - yyVAL.empty = struct{}{} + yyVAL.val = struct{}{} + } + case 1772: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8741 +>>>>>>> Stashed changes + { + yyVAL.val = struct{}{} } case 1773: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8832 +//line sql3.y:8745 { - yyVAL.empty = struct{}{} + yyVAL.val = struct{}{} } case 1774: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8834 +======= +//line sql3.y:8747 +>>>>>>> Stashed changes { - yyVAL.empty = struct{}{} + yyVAL.val = struct{}{} } case 1775: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8837 +======= +//line sql3.y:8750 +>>>>>>> Stashed changes { - yyVAL.empty = struct{}{} + yyVAL.val = struct{}{} } case 1776: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8839 +======= +//line sql3.y:8752 +>>>>>>> Stashed changes { - yyVAL.empty = struct{}{} + yyVAL.val = struct{}{} } case 1777: yyDollar = yyS[yypt-1 : yypt+1] -//line sql.y:8843 +//line sql3.y:8756 { +<<<<<<< Updated upstream yyVAL.str = UniqueStr } case 1778: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8845 +======= + yyVAL.val = UniqueStr + } + case 1778: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8758 + { + yyVAL.val = FulltextStr + } + case 1779: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8760 +>>>>>>> Stashed changes { - yyVAL.str = FulltextStr + yyVAL.val = SpatialStr } +<<<<<<< Updated upstream case 1779: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8847 +======= + case 1780: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8763 +>>>>>>> Stashed changes { - yyVAL.str = SpatialStr + yyVAL.val = "" } +<<<<<<< Updated upstream case 1780: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8850 +======= + case 1781: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8765 { - yyVAL.str = "" + yyVAL.val = yyDollar[1].val.(string) + } + case 1782: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8768 +>>>>>>> Stashed changes + { + yyVAL.val = ColIdent{} } +<<<<<<< Updated upstream case 1781: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8852 +======= + case 1783: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8770 +>>>>>>> Stashed changes { - yyVAL.str = yyDollar[1].str + yyVAL.val = yyDollar[2].val.(ColIdent) } +<<<<<<< Updated upstream case 1782: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8855 +======= + case 1784: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8774 +>>>>>>> Stashed changes { - yyVAL.colIdent = ColIdent{} + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } +<<<<<<< Updated upstream case 1783: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:8857 +======= + case 1785: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8778 +>>>>>>> Stashed changes { - yyVAL.colIdent = yyDollar[2].colIdent + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) } case 1784: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8861 +======= +//line sql3.y:8784 +>>>>>>> Stashed changes { - yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) + yyVAL.val = []ColIdent{yyDollar[1].val.(ColIdent)} } +<<<<<<< Updated upstream case 1785: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8865 @@ -23039,11 +27717,29 @@ yydefault: case 1787: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8875 +======= + case 1787: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8788 + { + yyVAL.val = append(yyVAL.val.([]ColIdent), yyDollar[3].val.(ColIdent)) + } + case 1789: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8795 +>>>>>>> Stashed changes + { + yyVAL.val = NewColIdent(string(yyDollar[1].bytes)) + } + case 1790: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8801 { - yyVAL.colIdents = append(yyVAL.colIdents, yyDollar[3].colIdent) + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) } case 1789: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8882 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) @@ -23069,17 +27765,37 @@ yydefault: case 1794: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8903 +======= +//line sql3.y:8805 { - yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) + } + case 1793: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8812 +>>>>>>> Stashed changes + { + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) + } + case 1794: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8816 + { + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) } case 1795: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8907 +======= +//line sql3.y:8820 +>>>>>>> Stashed changes { - yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) + yyVAL.val = NewTableIdent(string(yyDollar[1].bytes)) } case 1796: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8912 { yyVAL.str = string("") @@ -23093,56 +27809,121 @@ yydefault: case 1798: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8917 +======= +//line sql3.y:8825 { - yyVAL.str = string("") + yyVAL.val = string("") + } + case 1797: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8827 + { + yyVAL.val = string(yyDollar[2].bytes) + } + case 1798: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8830 +>>>>>>> Stashed changes + { + yyVAL.val = string("") } case 1799: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8919 +======= +//line sql3.y:8832 + { + yyVAL.val = IgnoreStr + } + case 1800: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8834 { - yyVAL.str = IgnoreStr + yyVAL.val = ReplaceStr + } + case 1801: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8837 +>>>>>>> Stashed changes + { + yyVAL.val = BoolVal(false) } case 1800: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8921 +======= +//line sql3.y:8839 +>>>>>>> Stashed changes { - yyVAL.str = ReplaceStr + yyVAL.val = BoolVal(true) } case 1801: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8924 +======= +//line sql3.y:8842 +>>>>>>> Stashed changes { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = &EnclosedBy{} } +<<<<<<< Updated upstream case 1802: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8926 +======= + case 1804: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8846 +>>>>>>> Stashed changes { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = &EnclosedBy{Optionally: yyDollar[1].val.(BoolVal), Delim: NewStrVal(yyDollar[4].bytes)} } case 1803: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8929 +======= +//line sql3.y:8851 +>>>>>>> Stashed changes { - yyVAL.EnclosedBy = nil + yyVAL.val = BoolVal(false) } +<<<<<<< Updated upstream case 1804: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:8933 +======= + case 1806: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8855 +>>>>>>> Stashed changes { - yyVAL.EnclosedBy = &EnclosedBy{Optionally: yyDollar[1].boolVal, Delim: NewStrVal(yyDollar[4].bytes)} + yyVAL.val = BoolVal(true) } case 1805: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8938 +======= +//line sql3.y:8860 +>>>>>>> Stashed changes { - yyVAL.boolVal = BoolVal(false) + yyVAL.val = &SQLVal{} } +<<<<<<< Updated upstream case 1806: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:8942 +======= + case 1808: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8864 +>>>>>>> Stashed changes { - yyVAL.boolVal = BoolVal(true) + yyVAL.val = NewStrVal(yyDollar[3].bytes) } case 1807: yyDollar = yyS[yypt-0 : yypt+1] @@ -23158,112 +27939,215 @@ yydefault: } case 1809: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8956 +======= +//line sql3.y:8869 +>>>>>>> Stashed changes { - yyVAL.sqlVal = nil + yyVAL.val = &SQLVal{} } case 1810: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8960 +======= +//line sql3.y:8873 +>>>>>>> Stashed changes { - yyVAL.sqlVal = NewStrVal(yyDollar[3].bytes) + yyVAL.val = NewStrVal(yyDollar[3].bytes) } case 1811: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8968 +======= +//line sql3.y:8881 { - yyVAL.Fields = nil + yyVAL.val = &Fields{} } case 1812: yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8885 + { + yyVAL.val = &Fields{TerminatedBy: yyDollar[2].val.(*SQLVal), EnclosedBy: yyDollar[3].val.(*EnclosedBy), EscapedBy: yyDollar[4].val.(*SQLVal)} + } + case 1813: + yyDollar = yyS[yypt-0 : yypt+1] +//line sql3.y:8890 +>>>>>>> Stashed changes + { + yyVAL.val = &Lines{} + } +<<<<<<< Updated upstream + case 1812: + yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:8972 +======= + case 1814: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8894 +>>>>>>> Stashed changes { - yyVAL.Fields = &Fields{TerminatedBy: yyDollar[2].sqlVal, EnclosedBy: yyDollar[3].EnclosedBy, EscapedBy: yyDollar[4].sqlVal} + yyVAL.val = &Lines{StartingBy: yyDollar[2].val.(*SQLVal), TerminatedBy: yyDollar[3].val.(*SQLVal)} } case 1813: yyDollar = yyS[yypt-0 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8977 +======= +//line sql3.y:8899 +>>>>>>> Stashed changes { - yyVAL.Lines = nil + yyVAL.val = &SQLVal{} } case 1814: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8981 +======= +//line sql3.y:8903 +>>>>>>> Stashed changes { - yyVAL.Lines = &Lines{StartingBy: yyDollar[2].sqlVal, TerminatedBy: yyDollar[3].sqlVal} + yyVAL.val = NewStrVal(yyDollar[3].bytes) } +<<<<<<< Updated upstream case 1815: yyDollar = yyS[yypt-0 : yypt+1] //line sql.y:8986 +======= + case 1817: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8909 +>>>>>>> Stashed changes { - yyVAL.sqlVal = nil + yyVAL.val = &LockTables{Tables: yyDollar[3].val.(TableAndLockTypes)} } +<<<<<<< Updated upstream case 1816: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:8990 +======= + case 1818: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8915 +>>>>>>> Stashed changes { - yyVAL.sqlVal = NewStrVal(yyDollar[3].bytes) + yyVAL.val = TableAndLockTypes{yyDollar[1].val.(*TableAndLockType)} } case 1817: yyDollar = yyS[yypt-3 : yypt+1] +<<<<<<< Updated upstream //line sql.y:8996 +======= +//line sql3.y:8919 +>>>>>>> Stashed changes { - yyVAL.statement = &LockTables{Tables: yyDollar[3].tableAndLockTypes} + yyVAL.val = append(yyDollar[1].val.(TableAndLockTypes), yyDollar[3].val.(*TableAndLockType)) } +<<<<<<< Updated upstream case 1818: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:9002 +======= + case 1820: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8925 +>>>>>>> Stashed changes { - yyVAL.tableAndLockTypes = TableAndLockTypes{yyDollar[1].tableAndLockType} + yyVAL.val = &TableAndLockType{Table: &AliasedTableExpr{Expr: yyDollar[1].val.(TableName)}, Lock: yyDollar[2].val.(LockType)} } +<<<<<<< Updated upstream case 1819: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:9006 +======= + case 1821: + yyDollar = yyS[yypt-4 : yypt+1] +//line sql3.y:8929 +>>>>>>> Stashed changes { - yyVAL.tableAndLockTypes = append(yyDollar[1].tableAndLockTypes, yyDollar[3].tableAndLockType) + yyVAL.val = &TableAndLockType{Table: &AliasedTableExpr{Expr: yyDollar[1].val.(TableName), As: yyDollar[3].val.(TableIdent)}, Lock: yyDollar[4].val.(LockType)} } +<<<<<<< Updated upstream case 1820: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:9012 +======= + case 1822: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:8935 +>>>>>>> Stashed changes { - yyVAL.tableAndLockType = &TableAndLockType{Table: &AliasedTableExpr{Expr: yyDollar[1].tableName}, Lock: yyDollar[2].lockType} + yyVAL.val = LockRead } +<<<<<<< Updated upstream case 1821: yyDollar = yyS[yypt-4 : yypt+1] //line sql.y:9016 +======= + case 1823: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8939 +>>>>>>> Stashed changes { - yyVAL.tableAndLockType = &TableAndLockType{Table: &AliasedTableExpr{Expr: yyDollar[1].tableName, As: yyDollar[3].tableIdent}, Lock: yyDollar[4].lockType} + yyVAL.val = LockReadLocal } case 1822: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:9022 +======= +//line sql3.y:8943 +>>>>>>> Stashed changes { - yyVAL.lockType = LockRead + yyVAL.val = LockWrite } case 1823: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:9026 +======= +//line sql3.y:8947 +>>>>>>> Stashed changes { - yyVAL.lockType = LockReadLocal + yyVAL.val = LockLowPriorityWrite } +<<<<<<< Updated upstream case 1824: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:9030 +======= + case 1826: + yyDollar = yyS[yypt-2 : yypt+1] +//line sql3.y:8953 +>>>>>>> Stashed changes { - yyVAL.lockType = LockWrite + yyVAL.val = &UnlockTables{} } case 1825: yyDollar = yyS[yypt-2 : yypt+1] +<<<<<<< Updated upstream //line sql.y:9034 +======= +//line sql3.y:8959 +>>>>>>> Stashed changes { - yyVAL.lockType = LockLowPriorityWrite + yyVAL.val = &Kill{Connection: true, ConnID: NewIntVal(yyDollar[2].bytes)} } +<<<<<<< Updated upstream case 1826: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:9040 +======= + case 1828: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8963 +>>>>>>> Stashed changes { - yyVAL.statement = &UnlockTables{} + yyVAL.val = &Kill{ConnID: NewIntVal(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1827: yyDollar = yyS[yypt-2 : yypt+1] //line sql.y:9046 @@ -23273,9 +28157,15 @@ yydefault: case 1828: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:9050 +======= + case 1829: + yyDollar = yyS[yypt-3 : yypt+1] +//line sql3.y:8967 +>>>>>>> Stashed changes { - yyVAL.statement = &Kill{ConnID: NewIntVal(yyDollar[3].bytes)} + yyVAL.val = &Kill{Connection: true, ConnID: NewIntVal(yyDollar[3].bytes)} } +<<<<<<< Updated upstream case 1829: yyDollar = yyS[yypt-3 : yypt+1] //line sql.y:9054 @@ -23285,6 +28175,11 @@ yydefault: case 2699: yyDollar = yyS[yypt-1 : yypt+1] //line sql.y:9968 +======= + case 2699: + yyDollar = yyS[yypt-1 : yypt+1] +//line sql3.y:9877 +>>>>>>> Stashed changes { if incNesting(yylex) { yylex.Error("max nesting level reached") @@ -23293,7 +28188,11 @@ yydefault: } case 2700: yyDollar = yyS[yypt-1 : yypt+1] +<<<<<<< Updated upstream //line sql.y:9977 +======= +//line sql3.y:9886 +>>>>>>> Stashed changes { decNesting(yylex) } diff --git a/go/vt/sqlparser/sql.y b/go/vt/sqlparser/sql.y index 86b97617ca1..2b40da0fe01 100755 --- a/go/vt/sqlparser/sql.y +++ b/go/vt/sqlparser/sql.y @@ -895,15 +895,17 @@ with_clause: base_select_no_cte: SELECT comment_opt query_opts select_expression_list into_opt from_opt where_expression_opt group_by_opt having_opt window_opt { + wh, _ := $7 + ha, _ := $9 $$ = &Select{ Comments: Comments($2), QueryOpts: $3, SelectExprs: $4, Into: $5, From: $6, - Where: NewWhere(WhereStr, $7), + Where: NewWhere(WhereStr, wh), GroupBy: GroupBy($8), - Having: NewWhere(HavingStr, $9), + Having: NewWhere(HavingStr, ha), Window: $10, } } @@ -914,11 +916,11 @@ base_select_no_cte: from_opt: { - $$ = nil + $$ = []byte(nil) } | FROM DUAL { - $$ = nil + $$ = []byte(nil) } | FROM table_references { @@ -2493,16 +2495,19 @@ declare_statement: } | DECLARE reserved_sql_id_list column_type charset_opt collate_opt { - $3.Charset = $4 - $3.Collate = $5 - $$ = &Declare{Variables: &DeclareVariables{Names: $2, VarType: $3}} + var ct ColumnType + ct = $3 + ct.Charset = $4 + ct.Collate = $5 + $$ = &Declare{Variables: &DeclareVariables{Names: $2, VarType: ct}} } | DECLARE reserved_sql_id_list column_type charset_opt collate_opt DEFAULT value_expression { - $3.Charset = $4 - $3.Collate = $5 - $3.Default = $7 - $$ = &Declare{Variables: &DeclareVariables{Names: $2, VarType: $3}} + ct := $3 + ct.Charset = $4 + ct.Collate = $5 + ct.Default = $7 + $$ = &Declare{Variables: &DeclareVariables{Names: $2, VarType: ct}} } declare_handler_action: @@ -2935,7 +2940,8 @@ table_column_list: column_definition: ID column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2943,7 +2949,8 @@ column_definition: } | all_non_reserved column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2953,7 +2960,8 @@ column_definition: column_definition_for_create: sql_id column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2961,7 +2969,8 @@ column_definition_for_create: } | column_name_safe_keyword column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2969,7 +2978,8 @@ column_definition_for_create: } | non_reserved_keyword2 column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2977,7 +2987,8 @@ column_definition_for_create: } | non_reserved_keyword3 column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2985,7 +2996,8 @@ column_definition_for_create: } | ESCAPE column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -2993,7 +3005,8 @@ column_definition_for_create: } | function_call_keywords column_type column_type_options { - if err := $2.merge($3); err != nil { + ct := $2 + if err := ct.merge($3); err != nil { yylex.Error(err.Error()) return 1 } @@ -3024,7 +3037,8 @@ column_type_options: | column_type_options NULL { opt := ColumnType{Null: BoolVal(true), NotNull: BoolVal(false), sawnull: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3033,7 +3047,8 @@ column_type_options: | column_type_options NOT NULL { opt := ColumnType{Null: BoolVal(false), NotNull: BoolVal(true), sawnull: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3042,7 +3057,8 @@ column_type_options: | column_type_options character_set { opt := ColumnType{Charset: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3051,7 +3067,8 @@ column_type_options: | column_type_options collate { opt := ColumnType{Collate: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3060,7 +3077,8 @@ column_type_options: | column_type_options BINARY { opt := ColumnType{BinaryCollate: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3069,7 +3087,8 @@ column_type_options: | column_type_options column_default { opt := ColumnType{Default: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3078,7 +3097,8 @@ column_type_options: | column_type_options on_update { opt := ColumnType{OnUpdate: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3087,7 +3107,8 @@ column_type_options: | column_type_options auto_increment { opt := ColumnType{Autoincrement: $2, sawai: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3096,7 +3117,8 @@ column_type_options: | column_type_options column_key { opt := ColumnType{KeyOpt: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3105,7 +3127,8 @@ column_type_options: | column_type_options column_comment { opt := ColumnType{Comment: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3114,7 +3137,8 @@ column_type_options: | column_type_options AS openb value_expression closeb stored_opt { opt := ColumnType{GeneratedExpr: &ParenExpr{$4}, Stored: $6} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3123,7 +3147,8 @@ column_type_options: | column_type_options GENERATED ALWAYS AS openb value_expression closeb stored_opt { opt := ColumnType{GeneratedExpr: &ParenExpr{$6}, Stored: $8} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3132,7 +3157,8 @@ column_type_options: | column_type_options SRID INTEGRAL { opt := ColumnType{SRID: NewIntVal($3)} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3142,7 +3168,8 @@ column_type_options: // TODO: This still needs support for "ON DELETE" and "ON UPDATE" { opt := ColumnType{ForeignKeyDef: &ForeignKeyDefinition{ReferencedTable: $3, ReferencedColumns: $5}} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3151,7 +3178,8 @@ column_type_options: | column_type_options check_constraint_definition { opt := ColumnType{Constraint: $2} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -3161,9 +3189,10 @@ column_type_options: column_type: numeric_type signed_or_unsigned_opt zero_fill_opt { - $$ = $1 - $$.Unsigned = $2 - $$.Zerofill = $3 + ct := $1 + ct.Unsigned = $2 + ct.Zerofill = $3 + $$ = ct } | char_type | time_type @@ -3172,8 +3201,9 @@ column_type: numeric_type: int_type length_opt { - $$ = $1 - $$.Length = $2 + ct := $1 + ct.Length = $2 + $$ = ct } | decimal_type { @@ -3245,51 +3275,59 @@ int_type: decimal_type: REAL float_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | DOUBLE float_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | DOUBLE PRECISION float_length_opt { - $$ = ColumnType{Type: string($1) + " " + string($2)} - $$.Length = $3.Length - $$.Scale = $3.Scale + ct := ColumnType{Type: string($1) + " " + string($2)} + ct.Length = $3.Length + ct.Scale = $3.Scale + $$ = ct } | FLOAT_TYPE decimal_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | DECIMAL decimal_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | NUMERIC decimal_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | DEC decimal_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | FIXED decimal_length_opt { - $$ = ColumnType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := ColumnType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } time_type: @@ -6192,7 +6230,15 @@ comment_opt: } comment_list { +<<<<<<< Updated upstream $$ = $1 +======= +<<<<<<< Updated upstream + $$ = $2 +======= + $$ = nil +>>>>>>> Stashed changes +>>>>>>> Stashed changes setAllowComments(yylex, false) } @@ -6254,7 +6300,8 @@ query_opts: | query_opts ALL { opt := QueryOpts{All: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -6263,7 +6310,8 @@ query_opts: | query_opts DISTINCT { opt := QueryOpts{Distinct: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -6272,7 +6320,8 @@ query_opts: | query_opts STRAIGHT_JOIN { opt := QueryOpts{StraightJoinHint: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -6281,7 +6330,8 @@ query_opts: | query_opts SQL_CALC_FOUND_ROWS { opt := QueryOpts{SQLCalcFoundRows: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -6290,7 +6340,8 @@ query_opts: | query_opts SQL_CACHE { opt := QueryOpts{SQLCache: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -6299,7 +6350,8 @@ query_opts: | query_opts SQL_NO_CACHE { opt := QueryOpts{SQLNoCache: true} - if err := $1.merge(opt); err != nil { + ct := $1 + if err := ct.merge(opt); err != nil { yylex.Error(err.Error()) return 1 } @@ -8133,9 +8185,10 @@ convert_type: } | DECIMAL decimal_length_opt { - $$ = &ConvertType{Type: string($1)} - $$.Length = $2.Length - $$.Scale = $2.Scale + ct := &ConvertType{Type: string($1)} + ct.Length = $2.Length + ct.Scale = $2.Scale + $$ = ct } | DOUBLE { @@ -8772,7 +8825,8 @@ set_expression_assignment: // The full fix is for any adjacent single-quoted or double-quoted strings to be concatenated but // this fixes the most pressing case. For more details, see: https://github.com/dolthub/dolt/issues/5232 // In other places we can correctly concatenate adjacent string literals, but the special comments break it - $$ = &SetVarExpr{Name: $1, Expr: NewStrVal([]byte(string($3)+string($4))), Scope: SetScope_None} + + $$ = &SetVarExpr{Name: $1.(*ColName), Expr: NewStrVal([]byte(string($3)+string($4))), Scope: SetScope_None} } | column_name assignment_op expression {