From d9d9b85daa59aba692aa914a496ed847d2272531 Mon Sep 17 00:00:00 2001 From: zhyass <34016424+zhyass@users.noreply.github.com> Date: Wed, 27 Jan 2021 20:44:28 +0800 Subject: [PATCH 1/2] *: add config lower-case-table-names to support case insensitive table name #725 [summary] 1. lower-case-table-names: If set false, table names are stored as specified and comparisons are case-sensitive. If set true, table names are stored in lowercase on disk and comparisons are not case-sensitive. 2. Change the type of show.Database to TableIdent to support case insensitive. [test case] src/ctl/v1/radon_test.go src/proxy/initdb_test.go src/proxy/proxy_test.go src/proxy/query_test.go src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_test.go [patch codecov] src/ctl/v1/radon.go 92.8% src/proxy/initdb.go 94.4% src/proxy/proxy.go 86.5% src/proxy/query.go 94.8% src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_funcs.go 94.7% src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.go 92.0% --- docs/api.md | 21 +- src/config/config.go | 11 +- src/ctl/v1/radon.go | 26 +- src/ctl/v1/radon_test.go | 45 +- src/proxy/initdb.go | 5 + src/proxy/initdb_test.go | 12 + src/proxy/proxy.go | 8 + src/proxy/proxy_test.go | 8 + src/proxy/query.go | 5 + src/proxy/query_test.go | 41 + src/proxy/show.go | 8 +- src/proxy/spanner.go | 4 + .../xelabs/go-mysqlstack/driver/server.go | 2 - .../xelabs/go-mysqlstack/sqlparser/ast.go | 12 +- .../go-mysqlstack/sqlparser/ast_funcs.go | 30 + .../go-mysqlstack/sqlparser/ast_test.go | 14 + .../go-mysqlstack/sqlparser/rewriter.go | 5 + .../xelabs/go-mysqlstack/sqlparser/sql.go | 1867 +++++++++-------- .../xelabs/go-mysqlstack/sqlparser/sql.y | 16 +- 19 files changed, 1141 insertions(+), 999 deletions(-) diff --git a/docs/api.md b/docs/api.md index 7d926558..265d48e5 100644 --- a/docs/api.md +++ b/docs/api.md @@ -55,16 +55,17 @@ This document describes the RadonDB REST API, which allows users to achieve most Path: /v1/radon/config Method: PUT Request: { - "max-connections": The maximum permitted number of simultaneous client connections, - "max-result-size": The maximum result size(in bytes) of a query, - "max-join-rows": The maximum number of rows that will be held in memory for join's intermediate results, - "ddl-timeout": The execution timeout(in millisecond) for DDL statements, - "query-timeout": The execution timeout(in millisecond) for DML statements, - "twopc-enable": Enables(true or false) radon two phase commit, for distrubuted transaction, - "allowip": ["allow-ip-1", "allow-ip-2", "allow-ip-regexp"], - "audit-mode": The audit log mode, "N": disabled, "R": read enabled, "W": write enabled, "A": read/write enabled, - "blocks-readonly": The size of a block when create hash tables, - "load-balance": Enables(0 or 1) load balance, for read-write separation. + "max-connections": The maximum permitted number of simultaneous client connections, + "max-result-size": The maximum result size(in bytes) of a query, + "max-join-rows": The maximum number of rows that will be held in memory for join's intermediate results, + "ddl-timeout": The execution timeout(in millisecond) for DDL statements, + "query-timeout": The execution timeout(in millisecond) for DML statements, + "twopc-enable": Enables(true or false) radon two phase commit, for distrubuted transaction, + "allowip": ["allow-ip-1", "allow-ip-2", "allow-ip-regexp"], + "audit-mode": The audit log mode, "N": disabled, "R": read enabled, "W": write enabled, "A": read/write enabled, + "blocks-readonly": The size of a block when create hash tables, + "load-balance": Enables(0 or 1) load balance, for read-write separation, + "lower-case-table-names": If set false, table names are stored as specified and comparisons are case-sensitive, else not case-sensitive. } ``` diff --git a/src/config/config.go b/src/config/config.go index 2ff9e264..4fff7ce6 100644 --- a/src/config/config.go +++ b/src/config/config.go @@ -24,11 +24,12 @@ const ( // ProxyConfig tuple. type ProxyConfig struct { - IPS []string `json:"allowip"` - MetaDir string `json:"meta-dir"` - Endpoint string `json:"endpoint"` - TwopcEnable bool `json:"twopc-enable"` - LoadBalance int `json:"load-balance"` // 0 -- disable balance, 1 -- enable balance to replica + IPS []string `json:"allowip"` + MetaDir string `json:"meta-dir"` + Endpoint string `json:"endpoint"` + TwopcEnable bool `json:"twopc-enable"` + LoadBalance int `json:"load-balance"` // 0 -- disable balance, 1 -- enable balance to replica + LowerCaseTableNames bool `json:"lower-case-table-names"` MaxConnections int `json:"max-connections"` MaxResultSize int `json:"max-result-size"` diff --git a/src/ctl/v1/radon.go b/src/ctl/v1/radon.go index 7e88fc43..ce5533f1 100644 --- a/src/ctl/v1/radon.go +++ b/src/ctl/v1/radon.go @@ -18,17 +18,18 @@ import ( ) type radonParams struct { - MaxConnections *int `json:"max-connections"` - MaxResultSize *int `json:"max-result-size"` - MaxJoinRows *int `json:"max-join-rows"` - DDLTimeout *int `json:"ddl-timeout"` - QueryTimeout *int `json:"query-timeout"` - TwoPCEnable *bool `json:"twopc-enable"` - LoadBalance *int `json:"load-balance"` - AllowIP []string `json:"allowip,omitempty"` - AuditMode *string `json:"audit-mode"` - StreamBufferSize *int `json:"stream-buffer-size"` - Blocks *int `json:"blocks-readonly"` + MaxConnections *int `json:"max-connections"` + MaxResultSize *int `json:"max-result-size"` + MaxJoinRows *int `json:"max-join-rows"` + DDLTimeout *int `json:"ddl-timeout"` + QueryTimeout *int `json:"query-timeout"` + TwoPCEnable *bool `json:"twopc-enable"` + LoadBalance *int `json:"load-balance"` + AllowIP []string `json:"allowip,omitempty"` + AuditMode *string `json:"audit-mode"` + StreamBufferSize *int `json:"stream-buffer-size"` + Blocks *int `json:"blocks-readonly"` + LowerCaseTableNames *bool `json:"lower-case-table-names"` } // RadonConfigHandler impl. @@ -80,6 +81,9 @@ func radonConfigHandler(log *xlog.Log, proxy *proxy.Proxy, w rest.ResponseWriter if p.Blocks != nil { proxy.SetBlocks(*p.Blocks) } + if p.LowerCaseTableNames != nil { + proxy.SetLowerCaseTableNames(*p.LowerCaseTableNames) + } // reset the allow ip table list. proxy.IPTable().Refresh() diff --git a/src/ctl/v1/radon_test.go b/src/ctl/v1/radon_test.go index ef8993eb..1ff512ed 100644 --- a/src/ctl/v1/radon_test.go +++ b/src/ctl/v1/radon_test.go @@ -36,33 +36,35 @@ func TestCtlV1RadonConfig(t *testing.T) { handler := api.MakeHandler() type radonParams1 struct { - MaxConnections int `json:"max-connections"` - MaxResultSize int `json:"max-result-size"` - MaxJoinRows int `json:"max-join-rows"` - DDLTimeout int `json:"ddl-timeout"` - QueryTimeout int `json:"query-timeout"` - TwoPCEnable bool `json:"twopc-enable"` - LoadBalance int `json:"load-balance"` - AllowIP []string `json:"allowip,omitempty"` - AuditMode string `json:"audit-mode"` - StreamBufferSize int `json:"stream-buffer-size"` - Blocks int `json:"blocks-readonly"` + MaxConnections int `json:"max-connections"` + MaxResultSize int `json:"max-result-size"` + MaxJoinRows int `json:"max-join-rows"` + DDLTimeout int `json:"ddl-timeout"` + QueryTimeout int `json:"query-timeout"` + TwoPCEnable bool `json:"twopc-enable"` + LoadBalance int `json:"load-balance"` + AllowIP []string `json:"allowip,omitempty"` + AuditMode string `json:"audit-mode"` + StreamBufferSize int `json:"stream-buffer-size"` + Blocks int `json:"blocks-readonly"` + LowerCaseTableNames bool `json:"lower-case-table-names"` } // 200. { // client p := &radonParams1{ - MaxConnections: 1023, - MaxResultSize: 1073741823, - MaxJoinRows: 32767, - QueryTimeout: 33, - TwoPCEnable: true, - LoadBalance: 1, - AllowIP: []string{"127.0.0.1", "127.0.0.2"}, - AuditMode: "A", - StreamBufferSize: 16777216, - Blocks: 128, + MaxConnections: 1023, + MaxResultSize: 1073741823, + MaxJoinRows: 32767, + QueryTimeout: 33, + TwoPCEnable: true, + LoadBalance: 1, + AllowIP: []string{"127.0.0.1", "127.0.0.2"}, + AuditMode: "A", + StreamBufferSize: 16777216, + Blocks: 128, + LowerCaseTableNames: true, } recorded := test.RunRequest(t, handler, test.MakeSimpleRequest("PUT", "http://localhost/v1/radon/config", p)) recorded.CodeIs(200) @@ -79,6 +81,7 @@ func TestCtlV1RadonConfig(t *testing.T) { assert.Equal(t, "A", radonConf.Audit.Mode) assert.Equal(t, 16777216, radonConf.Proxy.StreamBufferSize) assert.Equal(t, 128, radonConf.Router.Blocks) + assert.Equal(t, true, radonConf.Proxy.LowerCaseTableNames) } // Unset AllowIP. diff --git a/src/proxy/initdb.go b/src/proxy/initdb.go index b62f0d17..521cdfea 100644 --- a/src/proxy/initdb.go +++ b/src/proxy/initdb.go @@ -10,6 +10,7 @@ package proxy import ( "fmt" + "strings" "github.com/xelabs/go-mysqlstack/driver" "github.com/xelabs/go-mysqlstack/sqldb" @@ -25,6 +26,10 @@ func (spanner *Spanner) ComInitDB(session *driver.Session, database string) erro return err } + if spanner.isLowerCaseTableNames() { + database = strings.ToLower(database) + } + privilegePlug := spanner.plugins.PlugPrivilege() isSet := privilegePlug.CheckUserPrivilegeIsSet(session.User()) if !isSet { diff --git a/src/proxy/initdb_test.go b/src/proxy/initdb_test.go index 25dd0324..ddb4d79a 100644 --- a/src/proxy/initdb_test.go +++ b/src/proxy/initdb_test.go @@ -35,6 +35,18 @@ func TestProxyUseDatabase(t *testing.T) { assert.Nil(t, err) } + // lower case. + { + session := proxy.sessions.getSession(1).session + spanner := proxy.Spanner() + spanner.ComInitDB(session, "TEST") + assert.Equal(t, "TEST", session.Schema()) + + proxy.SetLowerCaseTableNames(true) + spanner.ComInitDB(session, "TEST") + assert.Equal(t, "test", session.Schema()) + } + // use db. { _, err := driver.NewConn("mock", "mock", address, "test", "utf8") diff --git a/src/proxy/proxy.go b/src/proxy/proxy.go index 520c480e..e3df9639 100644 --- a/src/proxy/proxy.go +++ b/src/proxy/proxy.go @@ -314,3 +314,11 @@ func (p *Proxy) SetBlocks(blocks int) { p.log.Info("proxy.SetBlocks:[%d->%d]", p.conf.Router.Blocks, blocks) p.conf.Router.Blocks = blocks } + +// SetLowerCaseTableNames used to set LowerCaseTableNames to false or true. +func (p *Proxy) SetLowerCaseTableNames(lowerCase bool) { + p.mu.Lock() + defer p.mu.Unlock() + p.log.Info("proxy.SetLowerCaseTableNames:[%v->%v]", p.conf.Proxy.LowerCaseTableNames, lowerCase) + p.conf.Proxy.LowerCaseTableNames = lowerCase +} diff --git a/src/proxy/proxy_test.go b/src/proxy/proxy_test.go index 7f7d84fa..cb266500 100644 --- a/src/proxy/proxy_test.go +++ b/src/proxy/proxy_test.go @@ -105,6 +105,14 @@ func TestProxy1(t *testing.T) { assert.Equal(t, 0, proxy.conf.Proxy.LoadBalance) } + // SetLowerCaseTableNames. + { + proxy.SetLowerCaseTableNames(true) + assert.Equal(t, true, proxy.conf.Proxy.LowerCaseTableNames) + proxy.SetLowerCaseTableNames(false) + assert.Equal(t, false, proxy.conf.Proxy.LowerCaseTableNames) + } + // FlushConfig. { err := proxy.FlushConfig() diff --git a/src/proxy/query.go b/src/proxy/query.go index 5572e55e..8bb7bc21 100644 --- a/src/proxy/query.go +++ b/src/proxy/query.go @@ -89,6 +89,11 @@ func (spanner *Spanner) ComQuery(session *driver.Session, query string, bindVari return sqldb.NewSQLError(sqldb.ER_SYNTAX_ERROR, err.Error()) } } + + if spanner.isLowerCaseTableNames() { + node = sqlparser.LowerCaseTableNames(node).(sqlparser.Statement) + query = sqlparser.String(node) + } log.Debug("query:%v", query) // Readonly check. diff --git a/src/proxy/query_test.go b/src/proxy/query_test.go index 7fd55b6c..111f442a 100644 --- a/src/proxy/query_test.go +++ b/src/proxy/query_test.go @@ -733,3 +733,44 @@ func TestProxyQueryNotSupport(t *testing.T) { expected := "unsupported.query:repair (errno 1105) (sqlstate HY000)" assert.EqualValues(t, expected, actual.Error()) } + +func TestProxyLowerCase(t *testing.T) { + log := xlog.NewStdLog(xlog.Level(xlog.PANIC)) + fakedbs, proxy, cleanup := MockProxy(log) + defer cleanup() + address := proxy.Address() + proxy.SetLowerCaseTableNames(true) + + // fakedbs. + { + fakedbs.AddQueryPattern("create .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("select .*", &sqltypes.Result{}) + } + + // create database. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + query := "create database TEST" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // create test table. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + query := "create table test.T1(id int, b int) partition by hash(id)" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // select. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + query := "select * from test.t1" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } +} diff --git a/src/proxy/show.go b/src/proxy/show.go index 73e1341a..faf59b63 100644 --- a/src/proxy/show.go +++ b/src/proxy/show.go @@ -79,8 +79,8 @@ func (spanner *Spanner) handleShowTableStatus(session *driver.Session, query str router := spanner.router database := session.Schema() - if ast.Database != "" { - database = ast.Database + if !ast.Database.IsEmpty() { + database = ast.Database.String() } if database == "" { @@ -204,8 +204,8 @@ func (spanner *Spanner) handleShowTables(session *driver.Session, query string, ast := node database := session.Schema() - if ast.Database != "" { - database = ast.Database + if !ast.Database.IsEmpty() { + database = ast.Database.String() } if database == "" { return nil, sqldb.NewSQLError(sqldb.ER_NO_DB_ERROR) diff --git a/src/proxy/spanner.go b/src/proxy/spanner.go index 4de6cab9..5e3c9a72 100644 --- a/src/proxy/spanner.go +++ b/src/proxy/spanner.go @@ -151,3 +151,7 @@ func (spanner *Spanner) isTwoPC() bool { func (spanner *Spanner) isAutocommitFalseIsTxn() bool { return spanner.conf.Proxy.AutocommitFalseIsTxn } + +func (spanner *Spanner) isLowerCaseTableNames() bool { + return spanner.conf.Proxy.LowerCaseTableNames +} diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/driver/server.go b/src/vendor/github.com/xelabs/go-mysqlstack/driver/server.go index 9d774374..ba40d372 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/driver/server.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/driver/server.go @@ -196,7 +196,6 @@ func (l *Listener) handle(conn net.Conn, ID uint32) { session.writeErrFromError(err) return } - session.SetSchema(db) } if err = session.packets.WriteOK(0, 0, session.greeting.Status(), 0); err != nil { @@ -227,7 +226,6 @@ func (l *Listener) handle(conn net.Conn, ID uint32) { return } } else { - session.SetSchema(db) if err = session.packets.WriteOK(0, 0, session.greeting.Status(), 0); err != nil { return } diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast.go b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast.go index 12ebc286..644a1134 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast.go @@ -174,7 +174,7 @@ type ( Type string Full string Table TableName - Database string + Database TableIdent From string Limit *Limit Filter *ShowFilter @@ -1193,18 +1193,18 @@ func (idxLA *IndexLockAndAlgorithm) Format(buf *TrackedBuffer) { func (node *Show) Format(buf *TrackedBuffer) { switch node.Type { case ShowCreateDatabaseStr: - buf.Myprintf("show %s %s", node.Type, node.Database) + buf.Myprintf("show %s %s", node.Type, node.Database.String()) case ShowTableStatusStr: buf.Myprintf("show %s", node.Type) - if node.Database != "" { - buf.Myprintf(" from %s", node.Database) + if !node.Database.IsEmpty() { + buf.Myprintf(" from %s", node.Database.String()) } case ShowCreateTableStr: buf.Myprintf("show %s %v", node.Type, node.Table) case ShowTablesStr: buf.Myprintf("show %s%s", node.Full, node.Type) - if node.Database != "" { - buf.Myprintf(" from %s", node.Database) + if !node.Database.IsEmpty() { + buf.Myprintf(" from %s", node.Database.String()) } if node.Filter != nil { buf.Myprintf("%v", node.Filter) diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_funcs.go b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_funcs.go index 323dcbf2..3addbd4e 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_funcs.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_funcs.go @@ -70,6 +70,36 @@ func Append(buf *strings.Builder, node SQLNode) { node.Format(tbuf) } +// LowerCaseTableNames use to lower case the table names(table ident). +func LowerCaseTableNames(stmt SQLNode) SQLNode { + return Rewrite(stmt, func(cursor *Cursor) bool { + switch n := cursor.Node().(type) { + case TableName: + if !n.IsEmpty() { + name := NewTableIdent(strings.ToLower(n.Name.v)) + qualifier := NewTableIdent("") + if !n.Qualifier.IsEmpty() { + qualifier.v = strings.ToLower(n.Qualifier.v) + } + tb := TableName{ + Name: name, + Qualifier: qualifier, + } + cursor.Replace(tb) + } + return false + case TableIdent: + if !n.IsEmpty() { + id := NewTableIdent(strings.ToLower(n.v)) + cursor.Replace(id) + } + return false + default: + return true + } + }, nil) +} + // AddWhere adds the boolean expression to the // WHERE clause as an AND condition. If the expression // is an OR clause, it parenthesizes it. Currently, diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_test.go b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_test.go index b46c99ef..60439e18 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_test.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/ast_test.go @@ -46,6 +46,20 @@ func TestAppend(t *testing.T) { } } +func TestLowerCaseTableNames(t *testing.T) { + tree, err := Parse("select tT.A from tEst.T as TT where a = 1") + if err != nil { + t.Error(err) + } + + node := LowerCaseTableNames(tree) + got := String(node) + want := "select tt.A from test.t as tt where a = 1" + if got != want { + t.Errorf("Append: %s, want %s", got, want) + } +} + func TestSelect(t *testing.T) { tree, err := Parse("select * from t where a = 1") if err != nil { diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/rewriter.go b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/rewriter.go index bb91d7c3..5329f9d5 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/rewriter.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/rewriter.go @@ -537,6 +537,10 @@ func (r *replaceSetExprsItems) inc() { *r++ } +func replaceShowDatabase(newNode, parent SQLNode) { + parent.(*Show).Database = newNode.(TableIdent) +} + func replaceShowFilter(newNode, parent SQLNode) { parent.(*Show).Filter = newNode.(*ShowFilter) } @@ -1049,6 +1053,7 @@ func (a *application) apply(parent, node SQLNode, replacer replacerFunc) { } case *Show: + a.apply(node, n.Database, replaceShowDatabase) a.apply(node, n.Filter, replaceShowFilter) a.apply(node, n.Limit, replaceShowLimit) a.apply(node, n.Table, replaceShowTable) diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.go b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.go index adc2ab47..1bdd77fd 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.go +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.go @@ -1,3 +1,5 @@ +// Code generated by goyacc -o sql.go sql.y. DO NOT EDIT. + //line sql.y:18 package sqlparser @@ -738,6 +740,7 @@ var yyToknames = [...]string{ "REBALANCE", "';'", } + var yyStatenames = [...]string{} const yyEofCode = 1 @@ -841,7 +844,6 @@ const yyPrivate = 57344 const yyLast = 12553 var yyAct = [...]int{ - 418, 1533, 1413, 1127, 471, 371, 846, 1554, 1462, 588, 1463, 1561, 395, 1412, 963, 424, 1592, 1347, 1409, 1567, 65, 393, 1374, 1152, 1175, 455, 1283, 1216, 983, 856, @@ -2099,8 +2101,8 @@ var yyAct = [...]int{ 0, 0, 0, 0, 0, 194, 195, 197, 196, 198, 129, 199, 200, } -var yyPact = [...]int{ +var yyPact = [...]int{ 1679, -1000, -215, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, 1165, 1212, @@ -2264,25 +2266,25 @@ var yyPact = [...]int{ -1000, -1000, 669, -84, -1000, 902, 427, -1000, 668, 167, -1000, -1000, -88, -1000, -1000, -1000, -102, -1000, } -var yyPgo = [...]int{ +var yyPgo = [...]int{ 0, 16, 17, 1535, 1526, 1522, 23, 1122, 1521, 1517, 1516, 1515, 59, 1514, 1513, 1512, 1511, 1509, 53, 1019, 1506, 1505, 1227, 1225, 1220, 1218, 1503, 1501, 1499, 1498, 1497, 1496, 1495, 1494, 1492, 1490, 1488, 1484, 1482, 113, 1481, 1480, 38, 1478, 1477, 1475, 98, 1470, 93, 1469, 1468, 1467, 58, 101, 55, 61, 214, 1466, 34, 41, - 37, 1465, 1464, 26, 1461, 1620, 90, 80, 1460, 60, - 99, 1459, 1457, 35, 1456, 1454, 1453, 1452, 1451, 1449, - 82, 105, 1448, 1447, 7, 50, 1446, 1445, 46, 95, - 212, 1442, 1441, 1440, 1439, 1438, 1437, 81, 9, 13, - 12, 2, 1435, 32, 5, 1433, 79, 1432, 1431, 1429, - 1420, 20, 1419, 77, 1418, 15, 75, 1417, 49, 1415, - 18, 6, 52, 1411, 1407, 71, 92, 89, 73, 1405, - 70, 1404, 1402, 102, 1401, 1400, 1399, 121, 1398, 100, - 527, 1397, 1396, 1395, 1393, 1392, 1390, 1389, 103, 62, - 29, 72, 0, 21, 25, 57, 1385, 4, 933, 44, - 39, 42, 107, 1384, 1383, 1541, 56, 87, 51, 1382, + 37, 1465, 1464, 26, 1461, 1620, 90, 80, 1460, 99, + 1459, 1457, 35, 1456, 1454, 1453, 1452, 1451, 1449, 82, + 105, 1448, 1447, 7, 50, 1446, 1445, 46, 95, 212, + 1442, 1441, 1440, 1439, 1438, 1437, 81, 9, 13, 12, + 2, 1435, 32, 5, 1433, 79, 1432, 1431, 1429, 1420, + 20, 1419, 77, 1418, 15, 75, 1417, 49, 1415, 18, + 6, 52, 1411, 1407, 71, 92, 89, 73, 1405, 70, + 1404, 1402, 102, 1401, 1400, 1399, 121, 1398, 100, 527, + 1397, 1396, 1395, 1393, 1392, 1390, 1389, 103, 62, 29, + 72, 0, 21, 25, 57, 1385, 4, 933, 44, 39, + 42, 107, 1384, 60, 1383, 1541, 56, 87, 51, 1382, 1381, 1380, 1378, 1377, 1373, 1372, 14, 1371, 1370, 1364, 1363, 1362, 1361, 1360, 1359, 1358, 1357, 1355, 1354, 1353, 1352, 1350, 1335, 83, 1334, 1331, 1330, 1326, 1324, 1319, @@ -2294,15 +2296,15 @@ var yyPgo = [...]int{ 1245, 22, 1243, 1241, 64, 85, 1240, 91, 1, 1238, 1236, 1235, 1234, 1232, 1229, 140, 376, 1222, 104, } -var yyR1 = [...]int{ +var yyR1 = [...]int{ 0, 263, 264, 264, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 19, 20, 20, 21, 21, 22, 22, 23, - 23, 44, 44, 44, 44, 45, 45, 45, 119, 119, - 118, 118, 24, 25, 25, 25, 262, 262, 262, 261, - 261, 150, 150, 67, 67, 81, 81, 27, 26, 26, + 23, 44, 44, 44, 44, 45, 45, 45, 118, 118, + 117, 117, 24, 25, 25, 25, 262, 262, 262, 261, + 261, 149, 149, 67, 67, 80, 80, 27, 26, 26, 259, 259, 258, 181, 181, 7, 7, 28, 28, 28, 28, 28, 260, 260, 260, 260, 260, 260, 250, 250, 251, 251, 243, 241, 241, 238, 238, 244, 244, 237, @@ -2317,7 +2319,7 @@ var yyR1 = [...]int{ 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 200, 201, 201, 202, 202, 203, 203, 204, 204, 186, 210, 210, 184, 180, 182, 231, 231, 231, 226, - 157, 157, 169, 169, 169, 169, 252, 252, 253, 253, + 156, 156, 169, 169, 169, 169, 252, 252, 253, 253, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 172, 172, 170, 170, 170, 170, 170, 170, 170, 170, 170, 171, 171, 171, 171, 171, 173, 173, 173, 173, @@ -2325,62 +2327,70 @@ var yyR1 = [...]int{ 174, 174, 174, 174, 174, 174, 175, 175, 175, 175, 175, 175, 175, 175, 225, 225, 176, 176, 216, 216, 217, 217, 217, 221, 221, 222, 222, 220, 220, 177, - 177, 177, 177, 177, 177, 43, 42, 42, 42, 135, - 135, 135, 218, 205, 205, 205, 179, 206, 206, 207, + 177, 177, 177, 177, 177, 43, 42, 42, 42, 134, + 134, 134, 218, 205, 205, 205, 179, 206, 206, 207, 207, 207, 208, 208, 208, 223, 223, 224, 224, 178, 227, 227, 227, 227, 6, 6, 245, 245, 245, 245, 240, 240, 4, 4, 4, 1, 2, 2, 3, 3, 3, 5, 5, 229, 229, 228, 228, 236, 236, 235, - 29, 29, 29, 29, 29, 29, 29, 29, 29, 163, - 163, 141, 141, 146, 146, 146, 30, 30, 30, 80, - 80, 147, 147, 8, 32, 9, 142, 142, 142, 74, - 74, 74, 10, 12, 12, 12, 12, 12, 75, 75, - 75, 75, 75, 75, 11, 11, 11, 11, 211, 211, - 211, 211, 211, 13, 145, 145, 145, 14, 16, 16, + 29, 29, 29, 29, 29, 29, 29, 29, 29, 162, + 162, 140, 140, 145, 145, 145, 30, 30, 30, 79, + 79, 146, 146, 8, 32, 9, 141, 141, 141, 73, + 73, 73, 10, 12, 12, 12, 12, 12, 74, 74, + 74, 74, 74, 74, 11, 11, 11, 11, 211, 211, + 211, 211, 211, 13, 144, 144, 144, 14, 16, 16, 16, 16, 15, 15, 15, 15, 15, 15, 15, 15, 15, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, - 51, 51, 72, 72, 72, 69, 69, 70, 70, 71, - 71, 68, 68, 73, 73, 73, 76, 76, 76, 36, - 148, 148, 34, 77, 77, 77, 37, 78, 78, 78, - 78, 78, 78, 79, 79, 38, 35, 267, 39, 40, + 51, 51, 71, 71, 71, 163, 163, 69, 69, 70, + 70, 68, 68, 72, 72, 72, 75, 75, 75, 36, + 147, 147, 34, 76, 76, 76, 37, 77, 77, 77, + 77, 77, 77, 78, 78, 38, 35, 267, 39, 40, 40, 41, 41, 41, 48, 48, 48, 46, 46, 47, - 47, 54, 54, 53, 53, 55, 55, 55, 55, 156, - 156, 156, 155, 155, 57, 57, 58, 58, 59, 59, - 60, 60, 60, 82, 61, 61, 61, 61, 164, 164, - 161, 161, 161, 160, 160, 62, 62, 62, 62, 63, - 63, 63, 63, 64, 64, 66, 66, 65, 65, 83, - 83, 83, 83, 84, 84, 85, 85, 56, 56, 56, - 56, 56, 56, 56, 138, 138, 219, 219, 86, 86, - 86, 86, 86, 86, 86, 86, 86, 86, 96, 96, - 96, 96, 96, 96, 87, 87, 87, 87, 87, 87, - 87, 52, 52, 97, 97, 97, 103, 98, 98, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, - 90, 90, 90, 90, 90, 90, 90, 90, 90, 94, - 94, 94, 92, 92, 92, 92, 92, 92, 92, 92, - 92, 93, 93, 93, 93, 93, 93, 93, 93, 268, - 268, 95, 95, 95, 95, 49, 49, 49, 49, 49, + 47, 54, 54, 53, 53, 55, 55, 55, 55, 155, + 155, 155, 154, 154, 57, 57, 58, 58, 59, 59, + 60, 60, 60, 81, 61, 61, 61, 61, 164, 164, + 160, 160, 160, 159, 159, 62, 62, 62, 62, 63, + 63, 63, 63, 64, 64, 66, 66, 65, 65, 82, + 82, 82, 82, 83, 83, 84, 84, 56, 56, 56, + 56, 56, 56, 56, 137, 137, 219, 219, 85, 85, + 85, 85, 85, 85, 85, 85, 85, 85, 95, 95, + 95, 95, 95, 95, 86, 86, 86, 86, 86, 86, + 86, 52, 52, 96, 96, 96, 102, 97, 97, 89, + 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, 89, 89, 89, 89, 89, 89, + 89, 89, 89, 89, 89, 89, 89, 89, 89, 93, + 93, 93, 91, 91, 91, 91, 91, 91, 91, 91, + 91, 92, 92, 92, 92, 92, 92, 92, 92, 268, + 268, 94, 94, 94, 94, 49, 49, 49, 49, 49, 166, 166, 168, 168, 168, 168, 168, 168, 168, 168, - 168, 168, 168, 168, 168, 107, 107, 50, 50, 105, - 105, 106, 108, 108, 104, 104, 104, 89, 89, 89, - 89, 89, 89, 89, 91, 91, 91, 109, 109, 110, - 110, 111, 111, 112, 112, 113, 114, 114, 114, 115, - 115, 115, 115, 116, 116, 116, 88, 88, 88, 88, - 88, 88, 117, 117, 117, 117, 120, 120, 99, 99, - 101, 101, 100, 102, 121, 121, 122, 123, 123, 126, - 126, 125, 125, 125, 125, 125, 134, 134, 133, 133, - 133, 124, 124, 127, 127, 131, 131, 130, 132, 132, - 132, 132, 129, 129, 128, 128, 167, 167, 167, 136, - 136, 139, 139, 140, 140, 137, 137, 143, 143, 143, - 143, 143, 143, 143, 143, 143, 143, 149, 149, 149, - 144, 144, 249, 249, 153, 153, 154, 154, 158, 158, - 159, 159, 162, 162, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, + 168, 168, 168, 168, 168, 106, 106, 50, 50, 104, + 104, 105, 107, 107, 103, 103, 103, 88, 88, 88, + 88, 88, 88, 88, 90, 90, 90, 108, 108, 109, + 109, 110, 110, 111, 111, 112, 113, 113, 113, 114, + 114, 114, 114, 115, 115, 115, 87, 87, 87, 87, + 87, 87, 116, 116, 116, 116, 119, 119, 98, 98, + 100, 100, 99, 101, 120, 120, 121, 122, 122, 125, + 125, 124, 124, 124, 124, 124, 133, 133, 132, 132, + 132, 123, 123, 126, 126, 130, 130, 129, 131, 131, + 131, 131, 128, 128, 127, 127, 167, 167, 167, 135, + 135, 138, 138, 139, 139, 136, 136, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 148, 148, 148, + 143, 143, 249, 249, 152, 152, 153, 153, 157, 157, + 158, 158, 161, 161, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 150, 150, 150, + 150, 150, 150, 150, 150, 150, 150, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, @@ -2388,18 +2398,10 @@ var yyR1 = [...]int{ 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, 151, - 151, 151, 151, 151, 151, 151, 151, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 152, 152, 152, 152, 152, - 152, 152, 152, 152, 152, 265, 266, 165, + 151, 151, 151, 151, 151, 265, 266, 165, } -var yyR2 = [...]int{ +var yyR2 = [...]int{ 0, 2, 0, 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, 4, @@ -2502,21 +2504,21 @@ var yyR2 = [...]int{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, } -var yyChk = [...]int{ +var yyChk = [...]int{ -1000, -263, -17, -18, -22, -23, -24, -25, -26, -28, -29, -30, -8, -32, -33, -36, -34, -9, -10, -11, -13, -14, -16, -15, -35, -27, -37, -38, -19, -20, 6, 7, 264, 8, 9, 45, -31, 131, 132, 133, - 156, 135, 151, 50, 70, 284, -142, 154, 291, 294, + 156, 135, 151, 50, 70, 284, -141, 154, 291, 294, 295, 298, 297, 313, 155, 10, 157, 49, -265, 150, - 149, 148, 73, -264, 321, -111, 15, -41, 5, -39, + 149, 148, 73, -264, 321, -110, 15, -41, 5, -39, -267, -39, -39, -39, -39, -39, -230, 73, -7, -249, - 24, 32, 144, 256, 257, 35, -137, 256, 140, -141, - 141, -7, 34, -147, 144, 144, 249, 131, 244, 286, - -71, -72, 288, 289, 251, 144, 290, 247, 287, 246, - 243, 181, 76, 47, 141, 28, 26, -148, 144, 245, - -158, 76, -152, 270, 20, 212, 158, 177, 271, 318, + 24, 32, 144, 256, 257, 35, -136, 256, 140, -140, + 141, -7, 34, -146, 144, 144, 249, 131, 244, 286, + -70, -71, 288, 289, 251, 144, 290, 247, 287, 246, + 243, 181, 76, 47, 141, 28, 26, -147, 144, 245, + -157, 76, -151, 270, 20, 212, 158, 177, 271, 318, 85, 211, 214, 215, 152, 173, 217, 216, 209, 167, 43, 207, 191, 292, 275, 280, 253, 206, 168, 277, 24, 192, 196, 299, 26, 219, 190, 27, 28, 272, @@ -2524,8 +2526,8 @@ var yyChk = [...]int{ 18, 222, 223, 193, 195, 274, 155, 224, 58, 203, 293, 295, 251, 208, 182, 171, 172, 279, 278, 156, 53, 276, 147, 174, 313, 314, 316, 315, 317, 319, - 320, -165, -65, -75, 135, -158, 277, 280, 282, -211, - 76, 78, -151, -152, 91, 39, 41, 201, 94, 164, + 320, -165, -65, -74, 135, -157, 277, 280, 282, -211, + 76, 78, -150, -151, 91, 39, 41, 201, 94, 164, 126, 186, 16, 22, 95, 48, 175, 178, 181, 49, 125, 252, 213, 265, 131, 68, 255, 258, 254, 256, 244, 169, 44, 9, 148, 149, 38, 119, 10, 133, @@ -2538,59 +2540,59 @@ var yyChk = [...]int{ 264, 30, 65, 257, 6, 268, 45, 151, 160, 63, 144, 245, 34, 187, 159, 183, 97, 145, 87, 290, 5, 35, 204, 8, 70, 146, 261, 262, 263, 54, - 179, 176, 287, 273, 96, 12, 205, -145, 274, 214, + 179, 176, 287, 273, 96, 12, 205, -144, 274, 214, -165, 296, -165, -165, 314, 316, 315, 317, 318, 320, - 284, -165, -98, -56, -86, 92, -90, 44, 40, -89, - -219, -104, -102, -103, 126, 115, 116, 123, 93, 127, - -94, -92, -93, -95, 78, 77, 79, 80, 81, 82, - 86, 87, 88, -153, -158, -100, -265, 64, 65, 265, + 284, -165, -97, -56, -85, 92, -89, 44, 40, -88, + -219, -103, -101, -102, 126, 115, 116, 123, 93, 127, + -93, -91, -92, -94, 78, 77, 79, 80, 81, 82, + 86, 87, 88, -152, -157, -99, -265, 64, 65, 265, 266, 269, 267, 95, 54, 254, 263, 262, 261, 259, - 260, 255, 258, 139, 256, 121, 264, 76, -152, -77, - 312, 300, -148, -18, -115, 17, 16, -21, -19, -265, + 260, 255, 258, 139, 256, 121, 264, 76, -151, -76, + 312, 300, -147, -18, -114, 17, 16, -21, -19, -265, 6, 37, 38, -48, 60, 61, -40, -44, 230, 229, - 231, -45, 230, 229, -65, -261, -123, -124, -126, 296, - -167, -125, 300, 301, 299, -154, -134, 302, -153, -151, - 181, 178, 76, -152, -260, 299, 293, 285, 281, -231, - -226, -157, 76, -152, -140, 139, 141, 141, 141, -140, - 144, -163, -162, 76, -152, -148, 76, -139, 139, -65, + 231, -45, 230, 229, -65, -261, -122, -123, -125, 296, + -167, -124, 300, 301, 299, -153, -133, 302, -152, -150, + 181, 178, 76, -151, -260, 299, 293, 285, 281, -231, + -226, -156, 76, -151, -139, 139, 141, 141, 141, -139, + 144, -162, -161, 76, -151, -147, 76, -138, 139, -65, -65, 248, 144, 256, -165, -165, 245, -68, 252, 253, - -70, 11, 110, -165, -165, -165, 251, -165, -165, -165, - -165, -165, -165, -165, -80, -65, -74, -157, 78, -12, + -69, 11, 110, -165, -165, -165, 251, -165, -165, -165, + -165, -165, -165, -165, -79, -65, -73, -156, 78, -12, 19, -18, -24, -22, -23, -25, -12, 277, 128, 100, - 79, -165, -100, -265, -100, -165, -65, -165, -165, 319, - 297, 298, 74, 91, 90, 107, -56, -87, 110, 92, + 79, -165, -99, -265, -99, -165, -65, -165, -165, 319, + 297, 298, 74, 91, 90, 107, -56, -86, 110, 92, 108, 109, 94, 112, 111, 122, 115, 116, 117, 118, 119, 120, 121, 113, 114, 125, 100, 101, 102, 103, - 104, 105, 106, -138, -265, -103, -265, 129, 130, -90, - -90, -90, -90, -90, -90, -265, 128, -18, -98, -265, - -265, -265, -265, -265, -265, -265, -107, -56, -265, -268, + 104, 105, 106, -137, -265, -102, -265, 129, 130, -89, + -89, -89, -89, -89, -89, -265, 128, -18, -97, -265, + -265, -265, -265, -265, -265, -265, -106, -56, -265, -268, -265, -268, -268, -268, -268, -268, -268, -268, -265, -265, - -265, -265, -148, -80, -266, 75, -116, 19, 46, -56, - -112, -113, -56, -111, -18, -39, 56, -46, 38, 84, - -137, -137, 45, 11, -81, -262, -67, 143, 230, 140, - -158, 74, -127, -130, -128, 303, 305, -125, 296, 100, - -133, -153, 78, 44, -133, 45, 16, 16, 75, 74, + -265, -265, -147, -79, -266, 75, -115, 19, 46, -56, + -111, -112, -56, -110, -18, -39, 56, -46, 38, 84, + -136, -136, 45, 11, -80, -262, -67, 143, 230, 140, + -157, 74, -126, -129, -127, 303, 305, -124, 296, 100, + -132, -152, 78, 44, -132, 45, 16, 16, 75, 74, -169, -172, -174, -173, -175, -170, -171, 175, 176, 126, 179, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 45, 152, 171, 172, 173, 174, 192, 193, 194, 195, 196, 197, 198, 199, 158, 177, 271, 159, 160, - 161, 162, 163, 164, 166, 167, 168, 169, 170, -162, + 161, 162, 163, 164, 166, 167, 168, 169, 170, -161, 92, 76, 76, 76, -65, -65, -255, -256, -257, -214, - 305, 44, -139, 72, -162, 40, -51, 11, -65, -158, - -69, -70, -70, -65, -69, 74, -76, 143, 280, 214, - 100, -159, -158, -151, 190, 278, 279, -165, -165, -165, - -149, 145, 39, -165, -165, -165, -56, -56, -56, -96, - 86, 92, 87, 88, -90, -97, -100, -103, 83, 110, - 108, 109, 94, -90, -90, -90, -90, -90, -90, -90, - -90, -90, -90, -90, -90, -90, -90, -90, -166, 76, - 78, 76, -89, -89, -153, -54, 38, -53, -55, 117, - -56, -158, -154, -159, -151, -266, -266, -18, -53, -53, - -56, -56, -53, -46, -105, -106, 96, -153, -266, -53, - -54, -53, -53, -80, -79, 8, 110, 74, 18, 74, - -114, 41, 148, -115, -266, -48, -91, -153, 79, 82, - -47, 63, -66, 42, -65, -66, -121, -122, -104, -153, - -158, -65, -81, -158, 11, 74, -150, 128, -126, -167, - -129, 74, -131, 74, 304, 306, 307, -127, 72, 89, + 305, 44, -138, 72, -161, 40, -51, 11, -65, -157, + -163, -69, -69, -65, -163, 74, -75, 143, 280, 214, + 100, -158, -157, -150, 190, 278, 279, -165, -165, -165, + -148, 145, 39, -165, -165, -165, -56, -56, -56, -95, + 86, 92, 87, 88, -89, -96, -99, -102, 83, 110, + 108, 109, 94, -89, -89, -89, -89, -89, -89, -89, + -89, -89, -89, -89, -89, -89, -89, -89, -166, 76, + 78, 76, -88, -88, -152, -54, 38, -53, -55, 117, + -56, -157, -153, -158, -150, -266, -266, -18, -53, -53, + -56, -56, -53, -46, -104, -105, 96, -152, -266, -53, + -54, -53, -53, -79, -78, 8, 110, 74, 18, 74, + -113, 41, 148, -114, -266, -48, -90, -152, 79, 82, + -47, 63, -66, 42, -65, -66, -120, -121, -103, -152, + -157, -65, -80, -157, 11, 74, -149, 128, -125, -167, + -128, 74, -130, 74, 304, 306, 307, -126, 72, 89, -56, -206, 125, -265, 283, 25, -232, -233, -234, -184, -180, -182, -183, -185, -186, -187, -188, -189, -190, -191, -192, -193, -194, -195, -196, -197, -198, -199, -200, -201, @@ -2603,72 +2605,72 @@ var yyChk = [...]int{ 208, -221, 204, -176, 73, -176, -176, -176, -176, -205, 178, -205, -205, -205, 73, 73, -176, -176, -176, -216, 73, -216, -216, -217, 73, -217, -255, 40, 72, 72, - 72, -143, 134, 292, 265, 136, 133, 137, 132, 201, + 72, -142, 134, 292, 265, 136, 133, 137, 132, 201, 178, 85, 44, 15, 276, 76, -257, 125, -212, -193, - 181, 178, 175, 307, -80, -65, -115, 250, -165, -165, - -73, 108, 12, -158, -65, -69, -165, -65, -165, 79, - 278, -65, 86, 87, 88, -97, -90, -90, -90, -52, - 153, 91, -266, -266, -53, 74, -156, -155, 39, -153, + 181, 178, 175, 307, -79, -65, -114, 250, -165, -165, + -72, 108, 12, -157, -65, -163, -165, -65, -165, 79, + 278, -65, 86, 87, 88, -96, -89, -89, -89, -52, + 153, 91, -266, -266, -53, 74, -155, -154, 39, -152, 78, 128, -265, 128, -266, -266, -266, 74, 146, 39, - -266, -53, -108, -106, 98, -56, -266, -266, -266, -266, - -266, -78, 19, 143, 51, 52, 280, 48, 58, -56, - -56, -113, -116, -136, 19, 11, 54, 54, -53, -118, - 281, -65, -118, -85, 74, 12, 100, 128, -161, -160, - 39, -158, 78, 146, 128, -58, -59, -60, -61, -82, - -103, -265, -65, -67, 117, -159, -128, -130, -132, 308, - 305, 311, 76, -157, -265, -265, -234, -213, 100, -213, + -266, -53, -107, -105, 98, -56, -266, -266, -266, -266, + -266, -77, 19, 143, 51, 52, 280, 48, 58, -56, + -56, -112, -115, -135, 19, 11, 54, 54, -53, -117, + 281, -65, -117, -84, 74, 12, 100, 128, -160, -159, + 39, -157, 78, 146, 128, -58, -59, -60, -61, -81, + -102, -265, -65, -67, 117, -158, -127, -129, -131, 308, + 305, 311, 76, -156, -265, -265, -234, -213, 100, -213, 125, -212, -213, -213, -213, -213, -213, 216, 216, -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, -213, -6, 76, -229, -228, 142, 35, 33, -254, - 86, 78, 79, 80, 86, -42, -219, -135, 254, 259, + 86, 78, 79, 80, 86, -42, -219, -134, 254, 259, 260, 36, 36, 78, 8, -210, 76, 78, 206, 207, 44, 44, 209, 210, -222, 205, 79, -205, -205, 45, - -225, 78, -225, 79, 79, -65, -65, -65, -165, -149, - -144, 141, 36, 100, 145, 138, 138, 138, -213, -213, - 45, 45, -213, -146, 30, 22, -246, -247, -248, 46, - 20, -165, 78, 78, -56, -69, -85, -12, -165, -52, - 91, -90, -90, -266, -55, -155, 117, -159, -54, -154, + -225, 78, -225, 79, 79, -65, -65, -65, -165, -148, + -143, 141, 36, 100, 145, 138, 138, 138, -213, -213, + 45, 45, -213, -145, 30, 22, -246, -247, -248, 46, + 20, -165, 78, 78, -56, -163, -84, -12, -165, -52, + 91, -89, -89, -266, -55, -154, 117, -158, -54, -153, -168, 126, 175, 152, 173, 169, 190, 180, 203, 171, - 204, -166, -168, 270, -111, 99, -56, 97, 53, 59, - -65, -57, 11, -88, 45, 54, -18, -265, -265, -88, - 45, -111, -122, -56, -56, -154, -118, -160, -58, -159, - -85, 74, -62, -63, -64, 62, 66, 68, 63, 64, - 65, 69, -164, 39, -58, -265, -161, -150, 128, 305, - 309, 310, -266, -157, -157, 78, -210, -213, -213, 79, + 204, -166, -168, 270, -110, 99, -56, 97, 53, 59, + -65, -57, 11, -87, 45, 54, -18, -265, -265, -87, + 45, -110, -121, -56, -56, -153, -117, -159, -58, -158, + -84, 74, -62, -63, -64, 62, 66, 68, 63, 64, + 65, 69, -164, 39, -58, -265, -160, -149, 128, 305, + 309, 310, -266, -156, -156, 78, -210, -213, -213, 79, 79, 79, 78, 78, -213, -213, 79, 78, 76, 79, 79, 79, 79, 44, 78, 44, 207, 206, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 79, - 44, 79, 44, 79, 44, 76, -152, -2, -1, 146, + 44, 79, 44, 79, 44, 76, -151, -2, -1, 146, -6, 36, -229, 73, -42, 75, 76, 126, 75, 74, 75, 74, 75, 74, -265, -265, -265, -65, -165, 76, 178, -230, 76, -226, -251, 76, 44, -215, 76, 126, - 44, -209, 79, 44, -248, -247, -213, -213, -73, -90, + 44, -209, 79, 44, -248, -247, -213, -213, -72, -89, 128, -266, -266, -176, -176, -176, -217, -176, 163, -176, - 163, -266, -266, -265, -50, 268, -56, -85, -58, -120, - 72, -121, -99, -101, -100, -265, -18, -117, -157, -119, - -157, -121, -115, -85, -85, -59, -60, -59, -60, 62, - 62, 62, 67, 62, 67, 62, -63, -158, -266, -83, + 163, -266, -266, -265, -50, 268, -56, -84, -58, -119, + 72, -120, -98, -100, -99, -265, -18, -116, -156, -118, + -156, -120, -114, -84, -84, -59, -60, -59, -60, 62, + 62, 62, 67, 62, 67, 62, -63, -157, -266, -82, 70, 140, 71, -266, -266, -210, -210, 78, 78, 73, -3, 25, 21, 31, 73, -2, -6, 75, 79, 78, - 79, 79, -236, -235, -153, -236, -236, 45, -251, -251, - 117, -205, 76, -90, -266, 78, -109, 13, 43, -120, - 74, -266, -266, -266, 74, 128, 74, -266, -111, 72, + 79, 79, -236, -235, -152, -236, -236, 45, -251, -251, + 117, -205, 76, -89, -266, 78, -108, 13, 43, -119, + 74, -266, -266, -266, 74, 128, 74, -266, -110, 72, 72, 62, 62, 141, 141, 141, -265, -181, 282, -236, -236, 73, -2, 75, 75, 75, -266, 74, -176, -266, - -266, 76, -49, 110, 273, -110, 14, 16, 36, -101, - 54, -18, -265, -157, -153, -157, -115, -56, -56, -265, + -266, 76, -49, 110, 273, -109, 14, 16, 36, -100, + 54, -18, -265, -156, -152, -156, -114, -56, -56, -265, -265, -265, -259, -258, 281, 79, 75, 75, -236, 73, - -238, -235, -237, -239, -266, 271, 69, 274, -56, -98, - 8, -99, -18, 128, -84, -153, -84, -84, 74, -266, + -238, -235, -237, -239, -266, 271, 69, 274, -56, -97, + 8, -98, -18, 128, -83, -152, -83, -83, 74, -266, 76, -240, -240, 75, -236, -246, -244, -241, -243, 27, 85, 146, -246, -242, -241, 273, -246, -241, 59, 272, - 275, -121, -266, -157, -266, 74, -266, -266, -258, 54, + 275, -120, -266, -156, -266, 74, -266, -266, -258, 54, -245, 27, -1, 85, 273, -240, 75, -213, 78, -250, - 25, 21, 29, 59, -153, 110, -213, 78, 29, -240, - 79, 76, 273, -100, 79, 76, 274, 275, + 25, 21, 29, 59, -152, 110, -213, 78, 29, -240, + 79, 76, 273, -99, 79, 76, 274, 275, } -var yyDef = [...]int{ +var yyDef = [...]int{ 0, -2, 2, -2, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 691, 0, @@ -2832,8 +2834,8 @@ var yyDef = [...]int{ 88, 89, 0, 647, 544, 0, 0, 328, 0, 323, 93, 102, 0, 72, 326, 329, 0, 648, } -var yyTok1 = [...]int{ +var yyTok1 = [...]int{ 1, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, @@ -2848,8 +2850,8 @@ var yyTok1 = [...]int{ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 111, 3, 123, } -var yyTok2 = [...]int{ +var yyTok2 = [...]int{ 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, @@ -2877,6 +2879,7 @@ var yyTok2 = [...]int{ 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, } + var yyTok3 = [...]int{ 57600, 275, 57601, 276, 57602, 277, 57603, 278, 57604, 279, 57605, 280, 57606, 281, 57607, 282, 57608, 283, 57609, 284, @@ -3229,29 +3232,29 @@ yydefault: case 1: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1101 +//line sql.y:1101 { setParseTree(yylex, yyDollar[1].statement) } case 2: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1107 +//line sql.y:1107 { } case 3: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1109 +//line sql.y:1109 { } case 4: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1113 +//line sql.y:1113 { yyVAL.statement = yyDollar[1].selStmt } case 29: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1143 +//line sql.y:1143 { sel := yyDollar[1].selStmt.(*Select) sel.OrderBy = yyDollar[2].orderBy @@ -3261,49 +3264,49 @@ yydefault: } case 30: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:1151 +//line sql.y:1151 { yyVAL.selStmt = &Union{Type: yyDollar[2].str, Left: yyDollar[1].selStmt, Right: yyDollar[3].selStmt, OrderBy: yyDollar[4].orderBy, Limit: yyDollar[5].limit, Lock: yyDollar[6].str} } case 31: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:1155 +//line sql.y:1155 { yyVAL.selStmt = &Select{Comments: Comments(yyDollar[2].bytes2), Cache: yyDollar[3].str, SelectExprs: SelectExprs{Nextval{Expr: yyDollar[5].expr}}, From: TableExprs{&AliasedTableExpr{Expr: yyDollar[7].tableName}}} } case 32: yyDollar = yyS[yypt-10 : yypt+1] - //line sql.y:1162 +//line sql.y:1162 { yyVAL.selStmt = &Select{Comments: Comments(yyDollar[2].bytes2), Cache: yyDollar[3].str, Distinct: yyDollar[4].str, Hints: yyDollar[5].str, SelectExprs: yyDollar[6].selectExprs, From: yyDollar[7].tableExprs, Where: NewWhere(WhereClause, yyDollar[8].expr), GroupBy: GroupBy(yyDollar[9].exprs), Having: NewWhere(HavingClause, yyDollar[10].expr)} } case 33: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1168 +//line sql.y:1168 { yyVAL.selStmt = yyDollar[1].selStmt } case 34: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1172 +//line sql.y:1172 { yyVAL.selStmt = &ParenSelect{Select: yyDollar[2].selStmt} } case 35: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1178 +//line sql.y:1178 { yyVAL.selStmt = yyDollar[1].selStmt } case 36: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1182 +//line sql.y:1182 { yyVAL.selStmt = &ParenSelect{Select: yyDollar[2].selStmt} } case 37: yyDollar = yyS[yypt-8 : yypt+1] - //line sql.y:1188 +//line sql.y:1188 { // insert_data returns a *Insert pre-filled with Columns & Values ins := yyDollar[7].ins @@ -3318,7 +3321,7 @@ yydefault: } case 38: yyDollar = yyS[yypt-9 : yypt+1] - //line sql.y:1201 +//line sql.y:1201 { cols := make(Columns, 0, len(yyDollar[8].updateExprs)) vals := make(ValTuple, 0, len(yyDollar[9].updateExprs)) @@ -3330,7 +3333,7 @@ yydefault: } case 39: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:1213 +//line sql.y:1213 { // insert_data returns a *Insert pre-filled with Columns & Values ins := yyDollar[7].ins @@ -3344,7 +3347,7 @@ yydefault: } case 40: yyDollar = yyS[yypt-8 : yypt+1] - //line sql.y:1225 +//line sql.y:1225 { cols := make(Columns, 0, len(yyDollar[8].updateExprs)) vals := make(ValTuple, 0, len(yyDollar[8].updateExprs)) @@ -3356,205 +3359,205 @@ yydefault: } case 41: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1236 +//line sql.y:1236 { yyVAL.str = "" } case 42: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1240 +//line sql.y:1240 { yyVAL.str = string(yyDollar[1].bytes) } case 43: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1244 +//line sql.y:1244 { yyVAL.str = string(yyDollar[1].bytes) } case 44: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1248 +//line sql.y:1248 { yyVAL.str = string(yyDollar[1].bytes) } case 45: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1253 +//line sql.y:1253 { } case 46: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1256 +//line sql.y:1256 { yyVAL.str = string(yyDollar[1].bytes) } case 47: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1260 +//line sql.y:1260 { yyVAL.str = string(yyDollar[1].bytes) } case 48: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1266 +//line sql.y:1266 { yyVAL.partitions = Partitions{yyDollar[1].colIdent} } case 49: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1270 +//line sql.y:1270 { yyVAL.partitions = append(yyVAL.partitions, yyDollar[3].colIdent) } case 50: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1275 +//line sql.y:1275 { yyVAL.partitions = nil } case 51: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1279 +//line sql.y:1279 { yyVAL.partitions = yyDollar[3].partitions } case 52: yyDollar = yyS[yypt-8 : yypt+1] - //line sql.y:1285 +//line sql.y:1285 { yyVAL.statement = &Update{Comments: Comments(yyDollar[2].bytes2), Table: yyDollar[3].tableName, Exprs: yyDollar[5].updateExprs, Where: NewWhere(WhereClause, yyDollar[6].expr), OrderBy: yyDollar[7].orderBy, Limit: yyDollar[8].limit} } case 53: yyDollar = yyS[yypt-10 : yypt+1] - //line sql.y:1291 +//line sql.y:1291 { // Single table yyVAL.statement = &Delete{Comments: Comments(yyDollar[2].bytes2), DeleteOptionList: (yyDollar[3].deleteOptionsList), TableRefs: TableExprs{&AliasedTableExpr{Expr: TableName{Qualifier: yyDollar[5].tableName.Qualifier, Name: yyDollar[5].tableName.Name}, As: yyDollar[6].tableIdent}}, Partitions: yyDollar[7].partitions, Where: NewWhere(WhereClause, yyDollar[8].expr), OrderBy: yyDollar[9].orderBy, Limit: yyDollar[10].limit, IsSingleTable: true} } case 54: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:1296 +//line sql.y:1296 { // Multi table yyVAL.statement = &Delete{Comments: Comments(yyDollar[2].bytes2), DeleteOptionList: (yyDollar[3].deleteOptionsList), TableList: yyDollar[4].tableNames, TableRefs: yyDollar[6].tableExprs, Where: NewWhere(WhereClause, yyDollar[7].expr), IsSingleTable: false, IsTableBeforeFrom: false} } case 55: yyDollar = yyS[yypt-8 : yypt+1] - //line sql.y:1301 +//line sql.y:1301 { // Multi table yyVAL.statement = &Delete{Comments: Comments(yyDollar[2].bytes2), DeleteOptionList: (yyDollar[3].deleteOptionsList), TableList: yyDollar[5].tableNames, TableRefs: yyDollar[7].tableExprs, Where: NewWhere(WhereClause, yyDollar[8].expr), IsSingleTable: false, IsTableBeforeFrom: false} } case 56: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1308 +//line sql.y:1308 { yyVAL.deleteOption = QuickOption } case 57: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1312 +//line sql.y:1312 { yyVAL.deleteOption = LowPriorityOption } case 58: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1316 +//line sql.y:1316 { yyVAL.deleteOption = IgnoreOption } case 59: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1321 +//line sql.y:1321 { yyVAL.deleteOptionsList = []DeleteOptionEnum{} } case 60: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1325 +//line sql.y:1325 { yyVAL.deleteOptionsList = append(yyDollar[1].deleteOptionsList, yyDollar[2].deleteOption) } case 61: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1330 +//line sql.y:1330 { } case 62: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1332 +//line sql.y:1332 { } case 63: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1336 +//line sql.y:1336 { yyVAL.tableName = TableName{Name: yyDollar[1].tableIdent} } case 64: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1340 +//line sql.y:1340 { yyVAL.tableName = TableName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent} } case 65: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1346 +//line sql.y:1346 { yyVAL.tableNames = TableNames{yyDollar[1].tableName} } case 66: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1350 +//line sql.y:1350 { yyVAL.tableNames = append(yyVAL.tableNames, yyDollar[3].tableName) } case 67: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1356 +//line sql.y:1356 { yyVAL.statement = &Do{Exprs: yyDollar[2].exprs} } case 68: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1362 +//line sql.y:1362 { yyVAL.statement = &Set{Comments: Comments(yyDollar[2].bytes2), Exprs: yyDollar[3].setExprs} } case 69: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1366 +//line sql.y:1366 { yyVAL.statement = &Set{Comments: Comments(yyDollar[2].bytes2), Exprs: yyDollar[3].setExprs} } case 70: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1372 +//line sql.y:1372 { yyVAL.partitionDefinitions = []*PartitionDefinition{yyDollar[1].partitionDefinition} } case 71: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1376 +//line sql.y:1376 { yyVAL.partitionDefinitions = append(yyDollar[1].partitionDefinitions, yyDollar[3].partitionDefinition) } case 72: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:1382 +//line sql.y:1382 { yyVAL.partitionDefinition = &PartitionDefinition{Backend: string(yyDollar[2].bytes), Row: yyDollar[5].valTuple} } case 73: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1388 +//line sql.y:1388 { yyVAL.optVal = nil } case 74: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1392 +//line sql.y:1392 { if string(yyDollar[2].bytes) == "0" { yylex.Error("Number of partitions must be a positive integer") @@ -3564,19 +3567,19 @@ yydefault: } case 75: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1402 +//line sql.y:1402 { yyVAL.str = string(yyDollar[1].bytes) } case 76: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1406 +//line sql.y:1406 { yyVAL.str = string(yyDollar[1].bytes) } case 77: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1412 +//line sql.y:1412 { yyDollar[1].ddl.Action = CreateTableStr yyDollar[1].ddl.TableSpec = yyDollar[2].tableSpec @@ -3585,7 +3588,7 @@ yydefault: } case 78: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:1419 +//line sql.y:1419 { var ifnotexists bool if yyDollar[3].byt != 0 { @@ -3595,43 +3598,43 @@ yydefault: } case 79: yyDollar = yyS[yypt-11 : yypt+1] - //line sql.y:1427 +//line sql.y:1427 { yyVAL.statement = &DDL{Action: CreateIndexStr, IndexType: yyDollar[2].str, IndexName: string(yyDollar[4].bytes), Table: yyDollar[6].tableName, NewName: yyDollar[6].tableName, IndexOpts: NewIndexOptions(yyDollar[8].indexColumns, yyDollar[10].indexOptionList), indexLockAndAlgorithm: yyDollar[11].indexLockAndAlgorithm} } case 80: yyDollar = yyS[yypt-11 : yypt+1] - //line sql.y:1431 +//line sql.y:1431 { yyVAL.statement = &DDL{Action: CreateIndexStr, IndexType: FullTextStr, IndexName: string(yyDollar[4].bytes), Table: yyDollar[6].tableName, NewName: yyDollar[6].tableName, IndexOpts: NewIndexOptions(yyDollar[8].indexColumns, yyDollar[10].indexOptionList), indexLockAndAlgorithm: yyDollar[11].indexLockAndAlgorithm} } case 81: yyDollar = yyS[yypt-11 : yypt+1] - //line sql.y:1435 +//line sql.y:1435 { yyVAL.statement = &DDL{Action: CreateIndexStr, IndexType: SpatialStr, IndexName: string(yyDollar[4].bytes), Table: yyDollar[6].tableName, NewName: yyDollar[6].tableName, IndexOpts: NewIndexOptions(yyDollar[8].indexColumns, yyDollar[10].indexOptionList), indexLockAndAlgorithm: yyDollar[11].indexLockAndAlgorithm} } case 82: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1441 +//line sql.y:1441 { yyVAL.partitionOption = &PartOptNormal{} } case 83: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1445 +//line sql.y:1445 { yyVAL.partitionOption = &PartOptGlobal{} } case 84: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1449 +//line sql.y:1449 { yyVAL.partitionOption = &PartOptSingle{} } case 85: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:1453 +//line sql.y:1453 { yyVAL.partitionOption = &PartOptSingle{ BackendName: yyDollar[4].colIdent.String(), @@ -3639,7 +3642,7 @@ yydefault: } case 86: yyDollar = yyS[yypt-9 : yypt+1] - //line sql.y:1459 +//line sql.y:1459 { yyVAL.partitionOption = &PartOptList{ Name: yyDollar[5].colIdent.String(), @@ -3648,7 +3651,7 @@ yydefault: } case 87: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:1466 +//line sql.y:1466 { yyVAL.partitionOption = &PartOptHash{ Name: yyDollar[5].colIdent.String(), @@ -3657,31 +3660,31 @@ yydefault: } case 88: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1475 +//line sql.y:1475 { yyVAL.str = "hash" } case 89: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1479 +//line sql.y:1479 { yyVAL.str = "btree" } case 90: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1485 +//line sql.y:1485 { yyVAL.str = string(yyDollar[1].bytes) } case 91: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1489 +//line sql.y:1489 { yyVAL.str = "default" } case 92: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1496 +//line sql.y:1496 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionUsing, @@ -3690,7 +3693,7 @@ yydefault: } case 93: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1505 +//line sql.y:1505 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionBlockSize, @@ -3699,7 +3702,7 @@ yydefault: } case 94: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1512 +//line sql.y:1512 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionComment, @@ -3708,49 +3711,49 @@ yydefault: } case 95: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1520 +//line sql.y:1520 { yyVAL.indexOptionList = []*IndexOption{} } case 96: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1524 +//line sql.y:1524 { yyVAL.indexOptionList = append(yyDollar[1].indexOptionList, yyDollar[2].indexOption) } case 97: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1530 +//line sql.y:1530 { yyVAL.indexOption = yyDollar[1].indexOption } case 98: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1534 +//line sql.y:1534 { yyVAL.indexOption = yyDollar[1].indexOption } case 99: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1539 +//line sql.y:1539 { yyVAL.indexOptionList = []*IndexOption{} } case 100: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1543 +//line sql.y:1543 { yyVAL.indexOptionList = append(yyDollar[1].indexOptionList, yyDollar[2].indexOption) } case 101: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1549 +//line sql.y:1549 { yyVAL.indexOption = yyDollar[1].indexOption } case 102: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1553 +//line sql.y:1553 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionParser, @@ -3759,19 +3762,19 @@ yydefault: } case 103: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1561 +//line sql.y:1561 { yyVAL.indexOptionList = []*IndexOption{} } case 104: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1565 +//line sql.y:1565 { yyVAL.indexOptionList = append(yyDollar[1].indexOptionList, yyDollar[2].indexOption) } case 105: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1570 +//line sql.y:1570 { yyVAL.indexLockAndAlgorithm = &IndexLockAndAlgorithm{ LockOption: LockOptionEmpty, @@ -3780,7 +3783,7 @@ yydefault: } case 106: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1577 +//line sql.y:1577 { yyVAL.indexLockAndAlgorithm = &IndexLockAndAlgorithm{ LockOption: yyDollar[1].lockOptionType, @@ -3789,7 +3792,7 @@ yydefault: } case 107: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1584 +//line sql.y:1584 { yyVAL.indexLockAndAlgorithm = &IndexLockAndAlgorithm{ LockOption: LockOptionEmpty, @@ -3798,7 +3801,7 @@ yydefault: } case 108: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1591 +//line sql.y:1591 { yyVAL.indexLockAndAlgorithm = &IndexLockAndAlgorithm{ LockOption: yyDollar[1].lockOptionType, @@ -3807,7 +3810,7 @@ yydefault: } case 109: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1598 +//line sql.y:1598 { yyVAL.indexLockAndAlgorithm = &IndexLockAndAlgorithm{ LockOption: yyDollar[2].lockOptionType, @@ -3816,7 +3819,7 @@ yydefault: } case 110: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1607 +//line sql.y:1607 { switch StrToLower(yyDollar[3].str) { case "none": @@ -3834,7 +3837,7 @@ yydefault: } case 111: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:1625 +//line sql.y:1625 { switch StrToLower(yyDollar[3].str) { case "default": @@ -3852,31 +3855,31 @@ yydefault: } case 112: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1642 +//line sql.y:1642 { yyVAL.databaseOptionListOpt.DBOptList = []*DatabaseOption{} } case 113: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1646 +//line sql.y:1646 { yyVAL.databaseOptionListOpt.DBOptList = yyDollar[1].databaseOptionList } case 114: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1652 +//line sql.y:1652 { yyVAL.databaseOptionList = append(yyVAL.databaseOptionList, yyDollar[1].databaseOption) } case 115: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1656 +//line sql.y:1656 { yyVAL.databaseOptionList = append(yyDollar[1].databaseOptionList, yyDollar[2].databaseOption) } case 116: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1665 +//line sql.y:1665 { switch string(yyDollar[1].bytes) { case "0", "1": @@ -3889,13 +3892,13 @@ yydefault: } case 117: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1676 +//line sql.y:1676 { yyVAL.str = "default" } case 118: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1682 +//line sql.y:1682 { yyVAL.databaseOption = &DatabaseOption{ OptType: string(yyDollar[2].bytes), @@ -3904,7 +3907,7 @@ yydefault: } case 119: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1689 +//line sql.y:1689 { yyVAL.databaseOption = &DatabaseOption{ OptType: string(yyDollar[2].str), @@ -3913,7 +3916,7 @@ yydefault: } case 120: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1696 +//line sql.y:1696 { yyVAL.databaseOption = &DatabaseOption{ OptType: "encryption", @@ -3922,7 +3925,7 @@ yydefault: } case 121: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1703 +//line sql.y:1703 { yyVAL.databaseOption = &DatabaseOption{ ReadOnlyValue: yyDollar[4].str, @@ -3930,63 +3933,63 @@ yydefault: } case 122: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1710 +//line sql.y:1710 { } case 123: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1712 +//line sql.y:1712 { } case 124: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1715 +//line sql.y:1715 { } case 125: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1717 +//line sql.y:1717 { } case 126: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1721 +//line sql.y:1721 { yyVAL.str = string(yyDollar[1].bytes) } case 127: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1725 +//line sql.y:1725 { yyVAL.str = "character set" } case 128: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1729 +//line sql.y:1729 { yyVAL.str = "char set" } case 129: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1735 +//line sql.y:1735 { yyVAL.str = string(yyDollar[1].bytes) } case 130: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1739 +//line sql.y:1739 { yyVAL.str = string(yyDollar[1].bytes) } case 131: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1743 +//line sql.y:1743 { yyVAL.str = "default" } case 132: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1749 +//line sql.y:1749 { var ifnotexists bool if yyDollar[3].byt != 0 { @@ -3997,7 +4000,7 @@ yydefault: } case 133: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:1760 +//line sql.y:1760 { yyVAL.tableSpec = yyDollar[2].tableSpec @@ -4079,31 +4082,31 @@ yydefault: } case 134: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:1841 +//line sql.y:1841 { yyVAL.tableOptionListOpt.TblOptList = []*TableOption{} } case 135: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1845 +//line sql.y:1845 { yyVAL.tableOptionListOpt.TblOptList = yyDollar[1].tableOptionList } case 136: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1851 +//line sql.y:1851 { yyVAL.tableOptionList = append(yyVAL.tableOptionList, yyDollar[1].tableOption) } case 137: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:1855 +//line sql.y:1855 { yyVAL.tableOptionList = append(yyDollar[1].tableOptionList, yyDollar[2].tableOption) } case 138: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1861 +//line sql.y:1861 { yyVAL.tableOption = &TableOption{ Type: TableOptionComment, @@ -4112,7 +4115,7 @@ yydefault: } case 139: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1868 +//line sql.y:1868 { yyVAL.tableOption = &TableOption{ Type: TableOptionEngine, @@ -4121,7 +4124,7 @@ yydefault: } case 140: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1875 +//line sql.y:1875 { yyVAL.tableOption = &TableOption{ Type: TableOptionCharset, @@ -4130,7 +4133,7 @@ yydefault: } case 141: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1882 +//line sql.y:1882 { yyVAL.tableOption = &TableOption{ Type: TableOptionAutoInc, @@ -4139,7 +4142,7 @@ yydefault: } case 142: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1889 +//line sql.y:1889 { yyVAL.tableOption = &TableOption{ Type: TableOptionAvgRowLength, @@ -4148,7 +4151,7 @@ yydefault: } case 143: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1896 +//line sql.y:1896 { yyVAL.tableOption = &TableOption{ Type: TableOptionChecksum, @@ -4157,7 +4160,7 @@ yydefault: } case 144: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1903 +//line sql.y:1903 { yyVAL.tableOption = &TableOption{ Type: TableOptionCollate, @@ -4166,7 +4169,7 @@ yydefault: } case 145: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1910 +//line sql.y:1910 { yyVAL.tableOption = &TableOption{ Type: TableOptionCompression, @@ -4175,7 +4178,7 @@ yydefault: } case 146: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1917 +//line sql.y:1917 { yyVAL.tableOption = &TableOption{ Type: TableOptionConnection, @@ -4184,7 +4187,7 @@ yydefault: } case 147: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1924 +//line sql.y:1924 { yyVAL.tableOption = &TableOption{ Type: TableOptionDataDirectory, @@ -4193,7 +4196,7 @@ yydefault: } case 148: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1931 +//line sql.y:1931 { yyVAL.tableOption = &TableOption{ Type: TableOptionIndexDirectory, @@ -4202,7 +4205,7 @@ yydefault: } case 149: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1938 +//line sql.y:1938 { yyVAL.tableOption = &TableOption{ Type: TableOptionDelayKeyWrite, @@ -4211,7 +4214,7 @@ yydefault: } case 150: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1945 +//line sql.y:1945 { yyVAL.tableOption = &TableOption{ Type: TableOptionEncryption, @@ -4220,7 +4223,7 @@ yydefault: } case 151: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1952 +//line sql.y:1952 { yyVAL.tableOption = &TableOption{ Type: TableOptionInsertMethod, @@ -4229,7 +4232,7 @@ yydefault: } case 152: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1959 +//line sql.y:1959 { yyVAL.tableOption = &TableOption{ Type: TableOptionKeyBlockSize, @@ -4238,7 +4241,7 @@ yydefault: } case 153: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1966 +//line sql.y:1966 { yyVAL.tableOption = &TableOption{ Type: TableOptionMaxRows, @@ -4247,7 +4250,7 @@ yydefault: } case 154: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1973 +//line sql.y:1973 { yyVAL.tableOption = &TableOption{ Type: TableOptionMinRows, @@ -4256,7 +4259,7 @@ yydefault: } case 155: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1980 +//line sql.y:1980 { yyVAL.tableOption = &TableOption{ Type: TableOptionPackKeys, @@ -4265,7 +4268,7 @@ yydefault: } case 156: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1987 +//line sql.y:1987 { yyVAL.tableOption = &TableOption{ Type: TableOptionPassword, @@ -4274,7 +4277,7 @@ yydefault: } case 157: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:1994 +//line sql.y:1994 { yyVAL.tableOption = &TableOption{ Type: TableOptionRowFormat, @@ -4283,7 +4286,7 @@ yydefault: } case 158: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2001 +//line sql.y:2001 { yyVAL.tableOption = &TableOption{ Type: TableOptionStatsAutoRecalc, @@ -4292,7 +4295,7 @@ yydefault: } case 159: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2008 +//line sql.y:2008 { yyVAL.tableOption = &TableOption{ Type: TableOptionStatsPersistent, @@ -4301,7 +4304,7 @@ yydefault: } case 160: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2015 +//line sql.y:2015 { yyVAL.tableOption = &TableOption{ Type: TableOptionStatsSamplePages, @@ -4310,7 +4313,7 @@ yydefault: } case 161: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2022 +//line sql.y:2022 { yyVAL.tableOption = &TableOption{ Type: TableOptionTableSpace, @@ -4319,24 +4322,24 @@ yydefault: } case 162: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2031 +//line sql.y:2031 { } case 163: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2035 +//line sql.y:2035 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 164: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2041 +//line sql.y:2041 { yyVAL.optVal = yyDollar[4].optVal } case 165: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2047 +//line sql.y:2047 { switch StrToLower(string(yyDollar[3].bytes)) { case "zlib", "lz4", "none": @@ -4349,31 +4352,31 @@ yydefault: } case 166: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2060 +//line sql.y:2060 { yyVAL.optVal = NewStrVal(yyDollar[3].bytes) } case 167: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2066 +//line sql.y:2066 { yyVAL.optVal = NewStrVal(yyDollar[4].bytes) } case 168: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2072 +//line sql.y:2072 { yyVAL.optVal = NewStrVal(yyDollar[4].bytes) } case 169: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2078 +//line sql.y:2078 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 170: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2084 +//line sql.y:2084 { switch string(yyDollar[3].bytes) { case "Y", "y": @@ -4389,7 +4392,7 @@ yydefault: } case 171: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2100 +//line sql.y:2100 { switch StrToLower(string(yyDollar[3].bytes)) { case "no", "first", "last": @@ -4402,232 +4405,232 @@ yydefault: } case 172: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2113 +//line sql.y:2113 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 173: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2119 +//line sql.y:2119 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 174: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2125 +//line sql.y:2125 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 175: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2131 +//line sql.y:2131 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 176: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2135 +//line sql.y:2135 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 177: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2141 +//line sql.y:2141 { yyVAL.optVal = NewStrVal(yyDollar[3].bytes) } case 178: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2149 +//line sql.y:2149 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 179: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2153 +//line sql.y:2153 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 180: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2157 +//line sql.y:2157 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 181: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2161 +//line sql.y:2161 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 182: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2165 +//line sql.y:2165 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 183: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2169 +//line sql.y:2169 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 184: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2173 +//line sql.y:2173 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 185: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2177 +//line sql.y:2177 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 186: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2181 +//line sql.y:2181 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 187: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2185 +//line sql.y:2185 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 188: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2189 +//line sql.y:2189 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 189: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2193 +//line sql.y:2193 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 190: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2197 +//line sql.y:2197 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 191: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2201 +//line sql.y:2201 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 192: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2207 +//line sql.y:2207 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 193: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2211 +//line sql.y:2211 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 194: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2217 +//line sql.y:2217 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 195: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2221 +//line sql.y:2221 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 196: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2228 +//line sql.y:2228 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 197: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2232 +//line sql.y:2232 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 198: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2238 +//line sql.y:2238 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 199: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2242 +//line sql.y:2242 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[3].bytes) } case 200: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2248 +//line sql.y:2248 { yyVAL.optVal = NewIntVal(yyDollar[3].bytes) } case 201: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2254 +//line sql.y:2254 { // Normal str as an identify, without quote yyVAL.optVal = NewStrValWithoutQuote(yyDollar[1].bytes) } case 202: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2259 +//line sql.y:2259 { // Str with Quote, it will be parsed by Lex begin with quote \' or \" yyVAL.optVal = NewStrVal(yyDollar[1].bytes) } case 203: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2266 +//line sql.y:2266 { yyVAL.optVal = NewStrVal(yyDollar[3].bytes) } case 204: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2272 +//line sql.y:2272 { yyVAL.optVal = yyDollar[3].optVal } case 205: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2278 +//line sql.y:2278 { yyVAL.optVal = yyDollar[4].optVal } case 206: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2284 +//line sql.y:2284 { yyVAL.tableSpec = &TableSpec{} yyVAL.tableSpec.AddColumn(yyDollar[1].columnDefinition) } case 207: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2289 +//line sql.y:2289 { yyVAL.tableSpec.AddColumn(yyDollar[3].columnDefinition) } case 208: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2293 +//line sql.y:2293 { yyVAL.tableSpec.AddIndex(yyDollar[3].indexDefinition) } case 209: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2299 +//line sql.y:2299 { yyDollar[2].columnType.NotNull = yyDollar[3].columnOptionListOpt.GetColumnOption(ColumnOptionNotNull).NotNull yyDollar[2].columnType.Autoincrement = yyDollar[3].columnOptionListOpt.GetColumnOption(ColumnOptionAutoincrement).Autoincrement @@ -4643,19 +4646,19 @@ yydefault: } case 210: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2315 +//line sql.y:2315 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 211: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2319 +//line sql.y:2319 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 212: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2325 +//line sql.y:2325 { yyVAL.columnType = yyDollar[1].columnType yyVAL.columnType.Unsigned = yyDollar[2].boolVal @@ -4663,31 +4666,31 @@ yydefault: } case 216: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2335 +//line sql.y:2335 { yyVAL.columnOptionListOpt.ColOptList = []*ColumnOption{} } case 217: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2339 +//line sql.y:2339 { yyVAL.columnOptionListOpt.ColOptList = yyDollar[1].columnOptionList } case 218: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2345 +//line sql.y:2345 { yyVAL.columnOptionList = append(yyVAL.columnOptionList, yyDollar[1].columnOption) } case 219: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2349 +//line sql.y:2349 { yyVAL.columnOptionList = append(yyDollar[1].columnOptionList, yyDollar[2].columnOption) } case 220: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2355 +//line sql.y:2355 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionNotNull, @@ -4696,7 +4699,7 @@ yydefault: } case 221: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2362 +//line sql.y:2362 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionDefault, @@ -4705,7 +4708,7 @@ yydefault: } case 222: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2369 +//line sql.y:2369 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionAutoincrement, @@ -4714,7 +4717,7 @@ yydefault: } case 223: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2376 +//line sql.y:2376 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionKeyPrimaryOpt, @@ -4723,7 +4726,7 @@ yydefault: } case 224: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2383 +//line sql.y:2383 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionKeyUniqueOpt, @@ -4732,7 +4735,7 @@ yydefault: } case 225: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2390 +//line sql.y:2390 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionComment, @@ -4741,7 +4744,7 @@ yydefault: } case 226: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2397 +//line sql.y:2397 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionOnUpdate, @@ -4750,7 +4753,7 @@ yydefault: } case 227: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2404 +//line sql.y:2404 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionCollate, @@ -4759,7 +4762,7 @@ yydefault: } case 228: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2411 +//line sql.y:2411 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionFormat, @@ -4768,7 +4771,7 @@ yydefault: } case 229: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2418 +//line sql.y:2418 { yyVAL.columnOption = &ColumnOption{ typ: ColumnOptionStorage, @@ -4777,74 +4780,74 @@ yydefault: } case 230: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2427 +//line sql.y:2427 { yyVAL.columnType = yyDollar[1].columnType yyVAL.columnType.Length = yyDollar[2].optVal } case 231: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2432 +//line sql.y:2432 { yyVAL.columnType = yyDollar[1].columnType } case 232: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2438 +//line sql.y:2438 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 233: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2442 +//line sql.y:2442 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 234: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2446 +//line sql.y:2446 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 235: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2450 +//line sql.y:2450 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 236: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2454 +//line sql.y:2454 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 237: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2458 +//line sql.y:2458 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 238: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2462 +//line sql.y:2462 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 239: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2466 +//line sql.y:2466 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 240: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2470 +//line sql.y:2470 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 241: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2476 +//line sql.y:2476 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} yyVAL.columnType.Length = yyDollar[2].lengthScaleOption.Length @@ -4852,7 +4855,7 @@ yydefault: } case 242: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2482 +//line sql.y:2482 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} yyVAL.columnType.Length = yyDollar[2].lengthScaleOption.Length @@ -4860,7 +4863,7 @@ yydefault: } case 243: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2488 +//line sql.y:2488 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} yyVAL.columnType.Length = yyDollar[2].lengthScaleOption.Length @@ -4868,7 +4871,7 @@ yydefault: } case 244: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2494 +//line sql.y:2494 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} yyVAL.columnType.Length = yyDollar[2].lengthScaleOption.Length @@ -4876,7 +4879,7 @@ yydefault: } case 245: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2500 +//line sql.y:2500 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} yyVAL.columnType.Length = yyDollar[2].lengthScaleOption.Length @@ -4884,206 +4887,206 @@ yydefault: } case 246: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2508 +//line sql.y:2508 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 247: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2512 +//line sql.y:2512 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 248: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2516 +//line sql.y:2516 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 249: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2520 +//line sql.y:2520 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 250: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2524 +//line sql.y:2524 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 251: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2530 +//line sql.y:2530 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal, Charset: yyDollar[3].str} } case 252: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2534 +//line sql.y:2534 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal, Charset: yyDollar[3].str} } case 253: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2538 +//line sql.y:2538 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 254: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2542 +//line sql.y:2542 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 255: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2546 +//line sql.y:2546 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Charset: yyDollar[2].str} } case 256: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2550 +//line sql.y:2550 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Charset: yyDollar[2].str} } case 257: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2554 +//line sql.y:2554 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Charset: yyDollar[2].str} } case 258: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2558 +//line sql.y:2558 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), Charset: yyDollar[2].str} } case 259: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2562 +//line sql.y:2562 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 260: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2566 +//line sql.y:2566 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 261: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2570 +//line sql.y:2570 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 262: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2574 +//line sql.y:2574 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 263: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2578 +//line sql.y:2578 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 264: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2582 +//line sql.y:2582 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].strs} } case 265: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2586 +//line sql.y:2586 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes), EnumValues: yyDollar[3].strs} } case 266: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2592 +//line sql.y:2592 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 267: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2596 +//line sql.y:2596 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 268: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2600 +//line sql.y:2600 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 269: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2604 +//line sql.y:2604 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 270: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2608 +//line sql.y:2608 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 271: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2612 +//line sql.y:2612 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 272: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2616 +//line sql.y:2616 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 273: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2620 +//line sql.y:2620 { yyVAL.columnType = ColumnType{Type: string(yyDollar[1].bytes)} } case 274: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2626 +//line sql.y:2626 { yyVAL.strs = make([]string, 0, 4) yyVAL.strs = append(yyVAL.strs, "'"+string(yyDollar[1].bytes)+"'") } case 275: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2631 +//line sql.y:2631 { yyVAL.strs = append(yyDollar[1].strs, "'"+string(yyDollar[3].bytes)+"'") } case 276: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2636 +//line sql.y:2636 { yyVAL.optVal = nil } case 277: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2640 +//line sql.y:2640 { yyVAL.optVal = NewIntVal(yyDollar[2].bytes) } case 278: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2645 +//line sql.y:2645 { yyVAL.lengthScaleOption = LengthScaleOption{} } case 279: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:2649 +//line sql.y:2649 { yyVAL.lengthScaleOption = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), @@ -5092,13 +5095,13 @@ yydefault: } case 280: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2657 +//line sql.y:2657 { yyVAL.lengthScaleOption = LengthScaleOption{} } case 281: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2661 +//line sql.y:2661 { yyVAL.lengthScaleOption = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), @@ -5106,7 +5109,7 @@ yydefault: } case 282: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:2667 +//line sql.y:2667 { yyVAL.lengthScaleOption = LengthScaleOption{ Length: NewIntVal(yyDollar[2].bytes), @@ -5115,73 +5118,73 @@ yydefault: } case 283: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2675 +//line sql.y:2675 { yyVAL.boolVal = BoolVal(false) } case 284: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2679 +//line sql.y:2679 { yyVAL.boolVal = BoolVal(true) } case 285: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2684 +//line sql.y:2684 { yyVAL.boolVal = BoolVal(false) } case 286: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2688 +//line sql.y:2688 { yyVAL.boolVal = BoolVal(true) } case 287: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2695 +//line sql.y:2695 { yyVAL.boolVal = BoolVal(false) } case 288: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2699 +//line sql.y:2699 { yyVAL.boolVal = BoolVal(true) } case 289: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2705 +//line sql.y:2705 { yyVAL.optVal = NewStrVal(yyDollar[2].bytes) } case 290: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2709 +//line sql.y:2709 { yyVAL.optVal = NewIntVal(yyDollar[2].bytes) } case 291: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2713 +//line sql.y:2713 { yyVAL.optVal = NewFloatVal(yyDollar[2].bytes) } case 292: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2717 +//line sql.y:2717 { yyVAL.optVal = NewValArg(yyDollar[2].bytes) } case 293: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2721 +//line sql.y:2721 { yyVAL.optVal = NewStrValWithoutQuote([]byte(yyDollar[2].str)) } case 294: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2725 +//line sql.y:2725 { if yyDollar[2].boolVal { yyVAL.optVal = NewStrValWithoutQuote([]byte("true")) @@ -5191,109 +5194,109 @@ yydefault: } case 295: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2735 +//line sql.y:2735 { yyVAL.str = yyDollar[3].str } case 296: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2741 +//line sql.y:2741 { yyVAL.str = string(yyDollar[1].bytes) } case 297: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2745 +//line sql.y:2745 { yyVAL.str = string(yyDollar[1].bytes) + "(" + ")" } case 298: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:2749 +//line sql.y:2749 { yyVAL.str = string(yyDollar[1].bytes) + "(" + string(yyDollar[3].bytes) + ")" } case 299: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2757 +//line sql.y:2757 { yyVAL.bytes = yyDollar[1].bytes } case 300: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2761 +//line sql.y:2761 { yyVAL.bytes = yyDollar[1].bytes } case 301: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2765 +//line sql.y:2765 { yyVAL.bytes = yyDollar[1].bytes } case 302: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2772 +//line sql.y:2772 { yyVAL.boolVal = BoolVal(true) } case 303: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2777 +//line sql.y:2777 { yyVAL.str = "" } case 304: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2781 +//line sql.y:2781 { yyVAL.str = string(yyDollar[3].bytes) } case 305: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2785 +//line sql.y:2785 { yyVAL.str = string(yyDollar[3].bytes) } case 306: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2792 +//line sql.y:2792 { yyVAL.optVal = yyDollar[2].optVal } case 307: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2797 +//line sql.y:2797 { yyVAL.str = "" } case 308: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2801 +//line sql.y:2801 { yyVAL.str = string(yyDollar[2].bytes) } case 309: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2807 +//line sql.y:2807 { yyVAL.str = string(yyDollar[2].bytes) } case 310: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2811 +//line sql.y:2811 { yyVAL.str = string(yyDollar[2].bytes) } case 311: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2815 +//line sql.y:2815 { yyVAL.str = string(yyDollar[2].bytes) } case 312: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2821 +//line sql.y:2821 { // "default" is not in official doc: https://dev.mysql.com/doc/refman/5.7/en/create-table.html // but actually mysql support it, see: https://github.com/mysql/mysql-server/blob/5.7/sql/sql_yacc.yy#L6953 @@ -5301,25 +5304,25 @@ yydefault: } case 313: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2827 +//line sql.y:2827 { yyVAL.str = string(yyDollar[2].bytes) } case 314: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2831 +//line sql.y:2831 { yyVAL.str = string(yyDollar[2].bytes) } case 315: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2837 +//line sql.y:2837 { yyVAL.colPrimaryKeyOpt = ColKeyPrimary } case 316: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2841 +//line sql.y:2841 { // KEY is normally a synonym for INDEX. The key attribute PRIMARY KEY // can also be specified as just KEY when given in a column definition. @@ -5328,25 +5331,25 @@ yydefault: } case 317: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2850 +//line sql.y:2850 { yyVAL.colUniqueKeyOpt = ColKeyUniqueKey } case 318: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2854 +//line sql.y:2854 { yyVAL.colUniqueKeyOpt = ColKeyUniqueKey } case 319: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2860 +//line sql.y:2860 { yyVAL.optVal = NewStrVal(yyDollar[2].bytes) } case 320: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:2866 +//line sql.y:2866 { // TODO(): in the future we'll support format out index_type, currently skip it. // If index_name is empty, becarful that the `name` result will be diffirent when doing format. @@ -5360,7 +5363,7 @@ yydefault: } case 321: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:2878 +//line sql.y:2878 { typ := string(yyDollar[1].bytes) if yyDollar[3].str != "" { @@ -5376,7 +5379,7 @@ yydefault: } case 322: yyDollar = yyS[yypt-8 : yypt+1] - //line sql.y:2892 +//line sql.y:2892 { // TODO(): in the future we'll support format out index_type, currently skip it yyVAL.indexDefinition = &IndexDefinition{ @@ -5389,7 +5392,7 @@ yydefault: } case 323: yyDollar = yyS[yypt-9 : yypt+1] - //line sql.y:2903 +//line sql.y:2903 { // TODO(): in the future we'll support format out index_type, currently skip it typ := string(yyDollar[2].bytes) @@ -5406,19 +5409,19 @@ yydefault: } case 324: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2919 +//line sql.y:2919 { yyVAL.str = "" } case 325: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2923 +//line sql.y:2923 { yyVAL.str = string(yyDollar[1].bytes) } case 326: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2929 +//line sql.y:2929 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionBlockSize, @@ -5427,7 +5430,7 @@ yydefault: } case 327: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2936 +//line sql.y:2936 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionUsing, @@ -5436,7 +5439,7 @@ yydefault: } case 328: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2943 +//line sql.y:2943 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionComment, @@ -5445,7 +5448,7 @@ yydefault: } case 329: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:2950 +//line sql.y:2950 { yyVAL.indexOption = &IndexOption{ Type: IndexOptionParser, @@ -5454,219 +5457,219 @@ yydefault: } case 330: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2958 +//line sql.y:2958 { yyVAL.indexOptionList = []*IndexOption{} } case 331: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2962 +//line sql.y:2962 { yyVAL.indexOptionList = append(yyDollar[1].indexOptionList, yyDollar[2].indexOption) } case 332: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2968 +//line sql.y:2968 { } case 333: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2971 +//line sql.y:2971 { } case 334: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2974 +//line sql.y:2974 { } case 335: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:2980 +//line sql.y:2980 { yyVAL.bytes = yyDollar[2].bytes } case 336: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:2985 +//line sql.y:2985 { } case 337: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2988 +//line sql.y:2988 { yyVAL.bytes = yyDollar[1].bytes } case 338: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2994 +//line sql.y:2994 { yyVAL.bytes = yyDollar[1].bytes } case 339: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:2998 +//line sql.y:2998 { yyVAL.bytes = yyDollar[1].bytes } case 340: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3002 +//line sql.y:3002 { yyVAL.bytes = yyDollar[1].bytes } case 341: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3008 +//line sql.y:3008 { yyVAL.bytes = yyDollar[1].bytes } case 342: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3012 +//line sql.y:3012 { yyVAL.bytes = yyDollar[1].bytes } case 343: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3017 +//line sql.y:3017 { // set empty yyVAL.str = "" } case 344: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3022 +//line sql.y:3022 { yyVAL.str = yyDollar[1].str } case 345: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3029 +//line sql.y:3029 { yyVAL.str = string(yyDollar[1].bytes) } case 346: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3033 +//line sql.y:3033 { yyVAL.str = string(yyDollar[1].bytes) } case 347: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3039 +//line sql.y:3039 { yyVAL.indexColumns = []*IndexColumn{yyDollar[1].indexColumn} } case 348: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3043 +//line sql.y:3043 { yyVAL.indexColumns = append(yyVAL.indexColumns, yyDollar[3].indexColumn) } case 349: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3049 +//line sql.y:3049 { yyVAL.indexColumn = &IndexColumn{Column: yyDollar[1].colIdent, Length: yyDollar[2].optVal} } case 350: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3055 +//line sql.y:3055 { yyVAL.statement = &DDL{Action: AlterStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName} } case 351: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3059 +//line sql.y:3059 { // Change this to a rename statement yyVAL.statement = &DDL{Action: RenameStr, Table: yyDollar[4].tableName, NewName: yyDollar[7].tableName} } case 352: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3064 +//line sql.y:3064 { // Rename an index can just be an alter yyVAL.statement = &DDL{Action: AlterStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName} } case 353: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3069 +//line sql.y:3069 { yyVAL.statement = &DDL{Action: AlterEngineStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName, Engine: string(yyDollar[7].bytes)} } case 354: yyDollar = yyS[yypt-9 : yypt+1] - //line sql.y:3073 +//line sql.y:3073 { yyVAL.statement = &DDL{Action: AlterCharsetStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName, Charset: string(yyDollar[9].bytes)} } case 355: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3077 +//line sql.y:3077 { yyVAL.statement = &DDL{Action: AlterAddColumnStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName, TableSpec: yyDollar[7].tableSpec} } case 356: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3081 +//line sql.y:3081 { yyVAL.statement = &DDL{Action: AlterDropColumnStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName, DropColumnName: string(yyDollar[7].bytes)} } case 357: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3085 +//line sql.y:3085 { yyVAL.statement = &DDL{Action: AlterModifyColumnStr, Table: yyDollar[4].tableName, NewName: yyDollar[4].tableName, ModifyColumnDef: yyDollar[7].columnDefinition} } case 358: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3089 +//line sql.y:3089 { yyVAL.statement = &DDL{Action: AlterDatabase, Database: yyDollar[3].tableIdent, DatabaseOptions: yyDollar[4].databaseOptionListOpt} } case 359: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3094 +//line sql.y:3094 { yyVAL.tableIdent = NewTableIdent("") } case 360: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3098 +//line sql.y:3098 { yyVAL.tableIdent = yyDollar[1].tableIdent } case 361: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3103 +//line sql.y:3103 { yyVAL.byt = 0 } case 362: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3107 +//line sql.y:3107 { yyVAL.byt = 1 } case 363: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3112 +//line sql.y:3112 { } case 364: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3114 +//line sql.y:3114 { } case 365: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3116 +//line sql.y:3116 { } case 366: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3120 +//line sql.y:3120 { var exists bool if yyDollar[4].byt != 0 { @@ -5680,13 +5683,13 @@ yydefault: } case 367: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3132 +//line sql.y:3132 { yyVAL.statement = &DDL{Action: DropIndexStr, IndexName: string(yyDollar[3].bytes), Table: yyDollar[5].tableName, NewName: yyDollar[5].tableName, indexLockAndAlgorithm: yyDollar[6].indexLockAndAlgorithm} } case 368: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3136 +//line sql.y:3136 { var exists bool if yyDollar[3].byt != 0 { @@ -5696,353 +5699,353 @@ yydefault: } case 369: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3146 +//line sql.y:3146 { yyVAL.tableNames = TableNames{yyDollar[1].tableName} } case 370: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3150 +//line sql.y:3150 { yyVAL.tableNames = append(yyVAL.tableNames, yyDollar[3].tableName) } case 371: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3156 +//line sql.y:3156 { } case 372: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3158 +//line sql.y:3158 { } case 373: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3162 +//line sql.y:3162 { yyVAL.statement = &DDL{Action: TruncateTableStr, Table: yyDollar[3].tableName, NewName: yyDollar[3].tableName} } case 374: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3168 +//line sql.y:3168 { yyVAL.statement = &DDL{Action: AlterStr, Table: yyDollar[3].tableName, NewName: yyDollar[3].tableName} } case 375: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3174 +//line sql.y:3174 { yyVAL.statement = &Xa{} } case 376: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3180 +//line sql.y:3180 { } case 377: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3182 +//line sql.y:3182 { } case 378: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3184 +//line sql.y:3184 { } case 379: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3187 +//line sql.y:3187 { yyVAL.showFilter = nil } case 380: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3191 +//line sql.y:3191 { yyVAL.showFilter = &ShowFilter{Like: yyDollar[1].colIdent.String()} } case 381: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3195 +//line sql.y:3195 { yyVAL.showFilter = &ShowFilter{Like: string(yyDollar[1].bytes)} } case 382: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3201 +//line sql.y:3201 { yyVAL.statement = &Show{Type: ShowColumnsStr, Table: yyDollar[2].tableName, Filter: yyDollar[3].showFilter} } case 383: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3207 +//line sql.y:3207 { yyVAL.statement = yyDollar[1].selStmt } case 384: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3211 +//line sql.y:3211 { yyVAL.statement = yyDollar[1].statement } case 385: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3215 +//line sql.y:3215 { yyVAL.statement = yyDollar[1].statement } case 386: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3219 +//line sql.y:3219 { yyVAL.statement = yyDollar[1].statement } case 387: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3223 +//line sql.y:3223 { yyVAL.statement = yyDollar[1].statement } case 388: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3228 +//line sql.y:3228 { yyVAL.explainType = ExplainTypeEmpty } case 389: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3232 +//line sql.y:3232 { yyVAL.explainType = ExplainTypeJSON } case 390: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3236 +//line sql.y:3236 { yyVAL.explainType = ExplainTypeTree } case 391: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3240 +//line sql.y:3240 { yyVAL.explainType = ExplainTypeTraditional } case 392: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3244 +//line sql.y:3244 { yyVAL.explainType = ExplainTypeExtended } case 393: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3248 +//line sql.y:3248 { yyVAL.explainType = ExplainTypePartitions } case 394: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3254 +//line sql.y:3254 { yyVAL.statement = &Explain{Type: yyDollar[2].explainType, Statement: yyDollar[3].statement} } case 395: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3258 +//line sql.y:3258 { // Currently we just parse it. yyVAL.statement = &Explain{Type: yyDollar[2].explainType, Statement: &OtherRead{}} } case 396: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3263 +//line sql.y:3263 { yyVAL.statement = &Explain{Type: ExplainTypeEmpty, Analyze: true, Statement: yyDollar[3].statement} } case 397: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3267 +//line sql.y:3267 { yyVAL.statement = &Explain{Type: ExplainTypeEmpty, Analyze: true, Statement: yyDollar[6].statement} } case 398: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3272 +//line sql.y:3272 { yyVAL.optVal = nil } case 399: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3276 +//line sql.y:3276 { // Normal str as an identify, without quote yyVAL.optVal = NewStrValWithoutQuote(yyDollar[1].bytes) } case 400: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3281 +//line sql.y:3281 { // Str with Quote, it will be parsed by Lex begin with quote \' or \" yyVAL.optVal = NewStrVal(yyDollar[1].bytes) } case 401: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3286 +//line sql.y:3286 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[1].bytes) } case 402: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3290 +//line sql.y:3290 { yyVAL.optVal = NewStrValWithoutQuote(yyDollar[1].bytes) } case 403: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3296 +//line sql.y:3296 { yyVAL.statement = &Help{HelpInfo: yyDollar[2].optVal} } case 404: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3301 +//line sql.y:3301 { } case 405: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3303 +//line sql.y:3303 { } case 406: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3305 +//line sql.y:3305 { } case 407: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3309 +//line sql.y:3309 { yyVAL.statement = &Kill{QueryID: &NumVal{raw: string(yyDollar[3].bytes)}} } case 408: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3315 +//line sql.y:3315 { yyVAL.statement = &Transaction{Action: BeginTxnStr} } case 409: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3319 +//line sql.y:3319 { yyVAL.statement = &Transaction{Action: StartTxnStr} } case 410: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3323 +//line sql.y:3323 { yyVAL.statement = &Transaction{Action: RollbackTxnStr} } case 411: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3327 +//line sql.y:3327 { yyVAL.statement = &Transaction{Action: CommitTxnStr} } case 412: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3333 +//line sql.y:3333 { yyVAL.statement = &Radon{Action: AttachStr, Row: yyDollar[3].valTuple} } case 413: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3337 +//line sql.y:3337 { yyVAL.statement = &Radon{Action: DetachStr, Row: yyDollar[3].valTuple} } case 414: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3341 +//line sql.y:3341 { yyVAL.statement = &Radon{Action: AttachListStr} } case 415: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3345 +//line sql.y:3345 { yyVAL.statement = &Radon{Action: ReshardStr, Table: yyDollar[3].tableName, NewName: yyDollar[5].tableName} } case 416: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3349 +//line sql.y:3349 { yyVAL.statement = &Radon{Action: CleanupStr} } case 417: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3353 +//line sql.y:3353 { yyVAL.statement = &Radon{Action: RebalanceStr} } case 418: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3357 +//line sql.y:3357 { yyVAL.statement = &Radon{Action: XARecoverStr} } case 419: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3361 +//line sql.y:3361 { yyVAL.statement = &Radon{Action: XACommitStr} } case 420: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3365 +//line sql.y:3365 { yyVAL.statement = &Radon{Action: XARollbackStr} } case 421: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3371 +//line sql.y:3371 { yyVAL.statement = &Show{Type: ShowBinlogEventsStr, From: yyDollar[4].str, Limit: yyDollar[5].limit} } case 422: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3375 +//line sql.y:3375 { yyVAL.statement = &Show{Type: ShowCreateTableStr, Table: yyDollar[4].tableName} } case 423: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3379 +//line sql.y:3379 { - yyVAL.statement = &Show{Type: ShowCreateDatabaseStr, Database: yyDollar[4].tableIdent.v} + yyVAL.statement = &Show{Type: ShowCreateDatabaseStr, Database: yyDollar[4].tableIdent} } case 424: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3383 +//line sql.y:3383 { yyVAL.statement = &Show{Type: ShowDatabasesStr} } case 425: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3387 +//line sql.y:3387 { yyVAL.statement = &Show{Type: ShowEnginesStr} } case 426: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3391 +//line sql.y:3391 { - yyVAL.statement = &Show{Full: yyDollar[2].str, Type: ShowTablesStr, Database: yyDollar[4].str, Filter: yyDollar[5].showFilter} + yyVAL.statement = &Show{Full: yyDollar[2].str, Type: ShowTablesStr, Database: yyDollar[4].tableIdent, Filter: yyDollar[5].showFilter} } case 427: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:3395 +//line sql.y:3395 { - if yyDollar[5].str != "" { - yyDollar[4].tableName.Qualifier.v = yyDollar[5].str + if yyDollar[5].tableIdent.v != "" { + yyDollar[4].tableName.Qualifier = yyDollar[5].tableIdent } var filter *ShowFilter if yyDollar[6].expr != nil { @@ -6052,621 +6055,621 @@ yydefault: } case 428: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:3406 +//line sql.y:3406 { - if yyDollar[6].str != "" { - yyDollar[5].tableName.Qualifier.v = yyDollar[6].str + if yyDollar[6].tableIdent.v != "" { + yyDollar[5].tableName.Qualifier = yyDollar[6].tableIdent } yyVAL.statement = &Show{Full: yyDollar[2].str, Type: ShowColumnsStr, Table: yyDollar[5].tableName, Filter: yyDollar[7].showFilter} } case 429: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3413 +//line sql.y:3413 { yyVAL.statement = &Show{Type: ShowProcesslistStr} } case 430: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3417 +//line sql.y:3417 { yyVAL.statement = &Show{Type: ShowQueryzStr} } case 431: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3421 +//line sql.y:3421 { yyVAL.statement = &Show{Type: ShowStatusStr} } case 432: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3425 +//line sql.y:3425 { - yyVAL.statement = &Show{Type: ShowTableStatusStr, Database: yyDollar[4].str} + yyVAL.statement = &Show{Type: ShowTableStatusStr, Database: yyDollar[4].tableIdent} } case 433: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3429 +//line sql.y:3429 { yyVAL.statement = &Show{Type: ShowTxnzStr} } case 434: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3433 +//line sql.y:3433 { yyVAL.statement = &Show{Type: ShowVariablesStr} } case 435: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3437 +//line sql.y:3437 { yyVAL.statement = &Show{Type: ShowVersionsStr} } case 436: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3441 +//line sql.y:3441 { yyVAL.statement = &Show{Type: ShowWarningsStr} } case 437: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3445 +//line sql.y:3445 { yyVAL.statement = &Show{Type: ShowCollationStr} } case 438: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3449 +//line sql.y:3449 { yyVAL.statement = &Show{Type: ShowCharsetStr} } case 439: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3453 +//line sql.y:3453 { yyVAL.statement = &Show{Type: ShowUnsupportedStr} } case 440: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3458 +//line sql.y:3458 { yyVAL.str = "" } case 441: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3462 +//line sql.y:3462 { yyVAL.str = string(yyDollar[3].bytes) } case 442: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3468 +//line sql.y:3468 { yyVAL.str = string(yyDollar[1].bytes) } case 443: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3472 +//line sql.y:3472 { yyVAL.str = string(yyDollar[1].bytes) } case 444: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3476 +//line sql.y:3476 { yyVAL.str = string(yyDollar[1].bytes) } case 445: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3482 +//line sql.y:3482 { - yyVAL.str = "" + yyVAL.tableIdent = NewTableIdent("") } case 446: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3486 +//line sql.y:3486 { - yyVAL.str = yyDollar[2].tableIdent.v + yyVAL.tableIdent = yyDollar[2].tableIdent } case 447: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3492 +//line sql.y:3492 { yyVAL.str = string(yyDollar[1].bytes) } case 448: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3496 +//line sql.y:3496 { yyVAL.str = string(yyDollar[1].bytes) } case 449: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3502 +//line sql.y:3502 { yyVAL.str = "" } case 450: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3506 +//line sql.y:3506 { yyVAL.str = "full " } case 451: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3512 +//line sql.y:3512 { yyVAL.str = string(yyDollar[1].bytes) } case 452: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3516 +//line sql.y:3516 { yyVAL.str = string(yyDollar[1].bytes) } case 453: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3522 +//line sql.y:3522 { yyVAL.showFilter = nil } case 454: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3526 +//line sql.y:3526 { yyVAL.showFilter = &ShowFilter{Like: string(yyDollar[2].bytes)} } case 455: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3530 +//line sql.y:3530 { yyVAL.showFilter = &ShowFilter{Filter: yyDollar[2].expr} } case 456: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3535 +//line sql.y:3535 { yyVAL.checksumOptionEnum = ChecksumOptionNone } case 457: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3539 +//line sql.y:3539 { yyVAL.checksumOptionEnum = ChecksumOptionQuick } case 458: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3543 +//line sql.y:3543 { yyVAL.checksumOptionEnum = ChecksumOptionExtended } case 459: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3549 +//line sql.y:3549 { yyVAL.statement = &Checksum{Tables: yyDollar[3].tableNames, ChecksumOption: yyDollar[4].checksumOptionEnum} } case 460: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3555 +//line sql.y:3555 { } case 461: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3557 +//line sql.y:3557 { } case 462: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3561 +//line sql.y:3561 { yyVAL.statement = &Use{DBName: yyDollar[2].tableIdent} } case 463: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3566 +//line sql.y:3566 { yyVAL.optimizeOptionEnum = OptimizeOptionNone } case 464: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3570 +//line sql.y:3570 { yyVAL.optimizeOptionEnum = OptimizeOptionNoWriteToBinlog } case 465: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3574 +//line sql.y:3574 { yyVAL.optimizeOptionEnum = OptimizeOptionLocal } case 466: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3580 +//line sql.y:3580 { yyVAL.statement = &Optimize{OptimizeOption: yyDollar[2].optimizeOptionEnum, Tables: yyDollar[4].tableNames} } case 467: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3586 +//line sql.y:3586 { yyVAL.checkOptionEnum = CheckOptionForUpgrade } case 468: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3590 +//line sql.y:3590 { yyVAL.checkOptionEnum = CheckOptionQuick } case 469: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3594 +//line sql.y:3594 { yyVAL.checkOptionEnum = CheckOptionFast } case 470: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3598 +//line sql.y:3598 { yyVAL.checkOptionEnum = CheckOptionMedium } case 471: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3602 +//line sql.y:3602 { yyVAL.checkOptionEnum = CheckOptionExtended } case 472: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3606 +//line sql.y:3606 { yyVAL.checkOptionEnum = CheckOptionChanged } case 473: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3611 +//line sql.y:3611 { yyVAL.checkOptionList = []CheckOptionEnum{} } case 474: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3615 +//line sql.y:3615 { yyVAL.checkOptionList = append(yyDollar[1].checkOptionList, yyDollar[2].checkOptionEnum) } case 475: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:3622 +//line sql.y:3622 { yyVAL.statement = &Check{Tables: yyDollar[3].tableNames, CheckOptions: yyDollar[4].checkOptionList} } case 476: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3628 +//line sql.y:3628 { yyVAL.statement = &OtherAdmin{} } case 477: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3633 +//line sql.y:3633 { setAllowComments(yylex, true) } case 478: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3636 +//line sql.y:3636 { yyVAL.bytes2 = yyDollar[2].bytes2 setAllowComments(yylex, false) } case 479: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3642 +//line sql.y:3642 { yyVAL.bytes2 = nil } case 480: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3646 +//line sql.y:3646 { yyVAL.bytes2 = append(yyDollar[1].bytes2, yyDollar[2].bytes) } case 481: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3652 +//line sql.y:3652 { yyVAL.str = UnionStr } case 482: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3656 +//line sql.y:3656 { yyVAL.str = UnionAllStr } case 483: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3660 +//line sql.y:3660 { yyVAL.str = UnionDistinctStr } case 484: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3665 +//line sql.y:3665 { yyVAL.str = "" } case 485: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3669 +//line sql.y:3669 { yyVAL.str = SQLNoCacheStr } case 486: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3673 +//line sql.y:3673 { yyVAL.str = SQLCacheStr } case 487: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3678 +//line sql.y:3678 { yyVAL.str = "" } case 488: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3682 +//line sql.y:3682 { yyVAL.str = DistinctStr } case 489: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3687 +//line sql.y:3687 { yyVAL.str = "" } case 490: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3691 +//line sql.y:3691 { yyVAL.str = StraightJoinHint } case 491: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3696 +//line sql.y:3696 { yyVAL.selectExprs = nil } case 492: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3700 +//line sql.y:3700 { yyVAL.selectExprs = yyDollar[1].selectExprs } case 493: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3706 +//line sql.y:3706 { yyVAL.selectExprs = SelectExprs{yyDollar[1].selectExpr} } case 494: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3710 +//line sql.y:3710 { yyVAL.selectExprs = append(yyVAL.selectExprs, yyDollar[3].selectExpr) } case 495: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3716 +//line sql.y:3716 { yyVAL.selectExpr = &StarExpr{} } case 496: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3720 +//line sql.y:3720 { yyVAL.selectExpr = &AliasedExpr{Expr: yyDollar[1].expr, As: yyDollar[2].colIdent} } case 497: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3724 +//line sql.y:3724 { yyVAL.selectExpr = &StarExpr{TableName: TableName{Name: yyDollar[1].tableIdent}} } case 498: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3728 +//line sql.y:3728 { yyVAL.selectExpr = &StarExpr{TableName: TableName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent}} } case 499: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3733 +//line sql.y:3733 { yyVAL.colIdent = ColIdent{} } case 500: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3737 +//line sql.y:3737 { yyVAL.colIdent = yyDollar[1].colIdent } case 501: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3741 +//line sql.y:3741 { yyVAL.colIdent = yyDollar[2].colIdent } case 503: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3748 +//line sql.y:3748 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 504: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3753 +//line sql.y:3753 { yyVAL.tableExprs = TableExprs{&AliasedTableExpr{Expr: TableName{Name: NewTableIdent("dual")}}} } case 505: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3757 +//line sql.y:3757 { yyVAL.tableExprs = yyDollar[2].tableExprs } case 506: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3763 +//line sql.y:3763 { yyVAL.tableExprs = TableExprs{yyDollar[1].tableExpr} } case 507: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3767 +//line sql.y:3767 { yyVAL.tableExprs = append(yyVAL.tableExprs, yyDollar[3].tableExpr) } case 510: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3777 +//line sql.y:3777 { yyVAL.tableExpr = yyDollar[1].aliasedTableName } case 511: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3781 +//line sql.y:3781 { yyVAL.tableExpr = &AliasedTableExpr{Expr: yyDollar[1].subquery, As: yyDollar[3].tableIdent} } case 512: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3785 +//line sql.y:3785 { yyVAL.tableExpr = &ParenTableExpr{Exprs: yyDollar[2].tableExprs} } case 513: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3791 +//line sql.y:3791 { yyVAL.aliasedTableName = &AliasedTableExpr{Expr: yyDollar[1].tableName, As: yyDollar[2].tableIdent, Hints: yyDollar[3].indexHints} } case 514: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3804 +//line sql.y:3804 { yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr} } case 515: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3808 +//line sql.y:3808 { yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr, On: yyDollar[5].expr} } case 516: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3812 +//line sql.y:3812 { yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr, On: yyDollar[5].expr} } case 517: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3816 +//line sql.y:3816 { yyVAL.tableExpr = &JoinTableExpr{LeftExpr: yyDollar[1].tableExpr, Join: yyDollar[2].str, RightExpr: yyDollar[3].tableExpr} } case 518: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3821 +//line sql.y:3821 { yyVAL.empty = struct{}{} } case 519: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3825 +//line sql.y:3825 { yyVAL.empty = struct{}{} } case 520: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3830 +//line sql.y:3830 { yyVAL.tableIdent = NewTableIdent("") } case 521: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3834 +//line sql.y:3834 { yyVAL.tableIdent = yyDollar[1].tableIdent } case 522: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3838 +//line sql.y:3838 { yyVAL.tableIdent = yyDollar[2].tableIdent } case 524: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3845 +//line sql.y:3845 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 525: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3851 +//line sql.y:3851 { yyVAL.str = JoinStr } case 526: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3855 +//line sql.y:3855 { yyVAL.str = JoinStr } case 527: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3859 +//line sql.y:3859 { yyVAL.str = JoinStr } case 528: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3863 +//line sql.y:3863 { yyVAL.str = StraightJoinStr } case 529: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3869 +//line sql.y:3869 { yyVAL.str = LeftJoinStr } case 530: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3873 +//line sql.y:3873 { yyVAL.str = LeftJoinStr } case 531: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3877 +//line sql.y:3877 { yyVAL.str = RightJoinStr } case 532: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3881 +//line sql.y:3881 { yyVAL.str = RightJoinStr } case 533: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3887 +//line sql.y:3887 { yyVAL.str = NaturalJoinStr } case 534: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3891 +//line sql.y:3891 { if yyDollar[2].str == LeftJoinStr { yyVAL.str = NaturalLeftJoinStr @@ -6676,457 +6679,457 @@ yydefault: } case 535: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3901 +//line sql.y:3901 { yyVAL.tableName = yyDollar[2].tableName } case 536: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3905 +//line sql.y:3905 { yyVAL.tableName = yyDollar[1].tableName } case 537: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3911 +//line sql.y:3911 { yyVAL.tableName = TableName{Name: yyDollar[1].tableIdent} } case 538: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3915 +//line sql.y:3915 { yyVAL.tableName = TableName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent} } case 539: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3920 +//line sql.y:3920 { yyVAL.indexHints = nil } case 540: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3924 +//line sql.y:3924 { yyVAL.indexHints = &IndexHints{Type: UseStr, Indexes: yyDollar[4].colIdents} } case 541: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3928 +//line sql.y:3928 { yyVAL.indexHints = &IndexHints{Type: IgnoreStr, Indexes: yyDollar[4].colIdents} } case 542: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:3932 +//line sql.y:3932 { yyVAL.indexHints = &IndexHints{Type: ForceStr, Indexes: yyDollar[4].colIdents} } case 543: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3938 +//line sql.y:3938 { yyVAL.colIdents = []ColIdent{yyDollar[1].colIdent} } case 544: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3942 +//line sql.y:3942 { yyVAL.colIdents = append(yyDollar[1].colIdents, yyDollar[3].colIdent) } case 545: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3947 +//line sql.y:3947 { yyVAL.expr = nil } case 546: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3951 +//line sql.y:3951 { yyVAL.expr = yyDollar[2].expr } case 547: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3957 +//line sql.y:3957 { yyVAL.expr = yyDollar[1].expr } case 548: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3961 +//line sql.y:3961 { yyVAL.expr = &AndExpr{Left: yyDollar[1].expr, Right: yyDollar[3].expr} } case 549: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3965 +//line sql.y:3965 { yyVAL.expr = &OrExpr{Left: yyDollar[1].expr, Right: yyDollar[3].expr} } case 550: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3969 +//line sql.y:3969 { yyVAL.expr = &NotExpr{Expr: yyDollar[2].expr} } case 551: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3973 +//line sql.y:3973 { yyVAL.expr = &IsExpr{Operator: yyDollar[3].str, Expr: yyDollar[1].expr} } case 552: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3977 +//line sql.y:3977 { yyVAL.expr = yyDollar[1].expr } case 553: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:3981 +//line sql.y:3981 { yyVAL.expr = &Default{ColName: yyDollar[2].str} } case 554: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:3987 +//line sql.y:3987 { yyVAL.str = "" } case 555: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:3991 +//line sql.y:3991 { yyVAL.str = string(yyDollar[2].bytes) } case 556: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:3997 +//line sql.y:3997 { yyVAL.boolVal = BoolVal(true) } case 557: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4001 +//line sql.y:4001 { yyVAL.boolVal = BoolVal(false) } case 558: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4007 +//line sql.y:4007 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: yyDollar[2].str, Right: yyDollar[3].expr} } case 559: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4011 +//line sql.y:4011 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: InStr, Right: yyDollar[3].colTuple} } case 560: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4015 +//line sql.y:4015 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotInStr, Right: yyDollar[4].colTuple} } case 561: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4019 +//line sql.y:4019 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: LikeStr, Right: yyDollar[3].expr, Escape: yyDollar[4].expr} } case 562: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4023 +//line sql.y:4023 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotLikeStr, Right: yyDollar[4].expr, Escape: yyDollar[5].expr} } case 563: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4027 +//line sql.y:4027 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: RegexpStr, Right: yyDollar[3].expr} } case 564: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4031 +//line sql.y:4031 { yyVAL.expr = &ComparisonExpr{Left: yyDollar[1].expr, Operator: NotRegexpStr, Right: yyDollar[4].expr} } case 565: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4035 +//line sql.y:4035 { yyVAL.expr = &RangeCond{Left: yyDollar[1].expr, Operator: BetweenStr, From: yyDollar[3].expr, To: yyDollar[5].expr} } case 566: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4039 +//line sql.y:4039 { yyVAL.expr = &RangeCond{Left: yyDollar[1].expr, Operator: NotBetweenStr, From: yyDollar[4].expr, To: yyDollar[6].expr} } case 567: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4043 +//line sql.y:4043 { yyVAL.expr = &ExistsExpr{Subquery: yyDollar[2].subquery} } case 568: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4049 +//line sql.y:4049 { yyVAL.str = IsNullStr } case 569: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4053 +//line sql.y:4053 { yyVAL.str = IsNotNullStr } case 570: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4057 +//line sql.y:4057 { yyVAL.str = IsTrueStr } case 571: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4061 +//line sql.y:4061 { yyVAL.str = IsNotTrueStr } case 572: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4065 +//line sql.y:4065 { yyVAL.str = IsFalseStr } case 573: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4069 +//line sql.y:4069 { yyVAL.str = IsNotFalseStr } case 574: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4075 +//line sql.y:4075 { yyVAL.str = EqualStr } case 575: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4079 +//line sql.y:4079 { yyVAL.str = LessThanStr } case 576: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4083 +//line sql.y:4083 { yyVAL.str = GreaterThanStr } case 577: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4087 +//line sql.y:4087 { yyVAL.str = LessEqualStr } case 578: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4091 +//line sql.y:4091 { yyVAL.str = GreaterEqualStr } case 579: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4095 +//line sql.y:4095 { yyVAL.str = NotEqualStr } case 580: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4099 +//line sql.y:4099 { yyVAL.str = NullSafeEqualStr } case 581: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4104 +//line sql.y:4104 { yyVAL.expr = nil } case 582: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4108 +//line sql.y:4108 { yyVAL.expr = yyDollar[2].expr } case 583: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4114 +//line sql.y:4114 { yyVAL.colTuple = yyDollar[1].valTuple } case 584: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4118 +//line sql.y:4118 { yyVAL.colTuple = yyDollar[1].subquery } case 585: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4122 +//line sql.y:4122 { yyVAL.colTuple = ListArg(yyDollar[1].bytes) } case 586: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4128 +//line sql.y:4128 { yyVAL.subquery = &Subquery{yyDollar[2].selStmt} } case 587: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4134 +//line sql.y:4134 { yyVAL.exprs = Exprs{yyDollar[1].expr} } case 588: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4138 +//line sql.y:4138 { yyVAL.exprs = append(yyDollar[1].exprs, yyDollar[3].expr) } case 589: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4144 +//line sql.y:4144 { yyVAL.expr = yyDollar[1].expr } case 590: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4148 +//line sql.y:4148 { yyVAL.expr = yyDollar[1].boolVal } case 591: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4152 +//line sql.y:4152 { yyVAL.expr = yyDollar[1].colName } case 592: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4156 +//line sql.y:4156 { yyVAL.expr = yyDollar[1].expr } case 593: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4160 +//line sql.y:4160 { yyVAL.expr = yyDollar[1].subquery } case 594: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4164 +//line sql.y:4164 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitAndStr, Right: yyDollar[3].expr} } case 595: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4168 +//line sql.y:4168 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitOrStr, Right: yyDollar[3].expr} } case 596: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4172 +//line sql.y:4172 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: BitXorStr, Right: yyDollar[3].expr} } case 597: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4176 +//line sql.y:4176 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: PlusStr, Right: yyDollar[3].expr} } case 598: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4180 +//line sql.y:4180 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: MinusStr, Right: yyDollar[3].expr} } case 599: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4184 +//line sql.y:4184 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: MultStr, Right: yyDollar[3].expr} } case 600: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4188 +//line sql.y:4188 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: DivStr, Right: yyDollar[3].expr} } case 601: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4192 +//line sql.y:4192 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: IntDivStr, Right: yyDollar[3].expr} } case 602: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4196 +//line sql.y:4196 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ModStr, Right: yyDollar[3].expr} } case 603: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4200 +//line sql.y:4200 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ModStr, Right: yyDollar[3].expr} } case 604: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4204 +//line sql.y:4204 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ShiftLeftStr, Right: yyDollar[3].expr} } case 605: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4208 +//line sql.y:4208 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].expr, Operator: ShiftRightStr, Right: yyDollar[3].expr} } case 606: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4212 +//line sql.y:4212 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].colName, Operator: JSONExtractOp, Right: yyDollar[3].expr} } case 607: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4216 +//line sql.y:4216 { yyVAL.expr = &BinaryExpr{Left: yyDollar[1].colName, Operator: JSONUnquoteExtractOp, Right: yyDollar[3].expr} } case 608: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4220 +//line sql.y:4220 { yyVAL.expr = &CollateExpr{Expr: yyDollar[1].expr, Charset: yyDollar[3].str} } case 609: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4224 +//line sql.y:4224 { yyVAL.expr = &UnaryExpr{Operator: BinaryStr, Expr: yyDollar[2].expr} } case 610: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4228 +//line sql.y:4228 { if num, ok := yyDollar[2].expr.(*SQLVal); ok && num.Type == IntVal { yyVAL.expr = num @@ -7136,7 +7139,7 @@ yydefault: } case 611: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4236 +//line sql.y:4236 { if num, ok := yyDollar[2].expr.(*SQLVal); ok && num.Type == IntVal { // Handle double negative @@ -7152,19 +7155,19 @@ yydefault: } case 612: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4250 +//line sql.y:4250 { yyVAL.expr = &UnaryExpr{Operator: TildaStr, Expr: yyDollar[2].expr} } case 613: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4254 +//line sql.y:4254 { yyVAL.expr = &UnaryExpr{Operator: BangStr, Expr: yyDollar[2].expr} } case 614: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4258 +//line sql.y:4258 { // This rule prevents the usage of INTERVAL // as a function. If support is needed for that, @@ -7174,223 +7177,223 @@ yydefault: } case 619: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4276 +//line sql.y:4276 { yyVAL.expr = &FuncExpr{Name: yyDollar[1].colIdent, Exprs: yyDollar[3].selectExprs} } case 620: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4280 +//line sql.y:4280 { yyVAL.expr = &FuncExpr{Name: yyDollar[1].colIdent, Distinct: true, Exprs: yyDollar[4].selectExprs} } case 621: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4284 +//line sql.y:4284 { yyVAL.expr = &FuncExpr{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].colIdent, Exprs: yyDollar[5].selectExprs} } case 622: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4294 +//line sql.y:4294 { yyVAL.expr = &FuncExpr{Name: NewColIdent("left"), Exprs: yyDollar[3].selectExprs} } case 623: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4298 +//line sql.y:4298 { yyVAL.expr = &FuncExpr{Name: NewColIdent("right"), Exprs: yyDollar[3].selectExprs} } case 624: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4302 +//line sql.y:4302 { yyVAL.expr = &ConvertExpr{Expr: yyDollar[3].expr, Type: yyDollar[5].convertType} } case 625: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4306 +//line sql.y:4306 { yyVAL.expr = &ConvertExpr{Expr: yyDollar[3].expr, Type: yyDollar[5].convertType} } case 626: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4310 +//line sql.y:4310 { yyVAL.expr = &ConvertUsingExpr{Expr: yyDollar[3].expr, Type: yyDollar[5].str} } case 627: yyDollar = yyS[yypt-9 : yypt+1] - //line sql.y:4314 +//line sql.y:4314 { yyVAL.expr = &MatchExpr{Columns: yyDollar[3].selectExprs, Expr: yyDollar[7].expr, Option: yyDollar[8].str} } case 628: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:4318 +//line sql.y:4318 { yyVAL.expr = &GroupConcatExpr{Distinct: yyDollar[3].str, Exprs: yyDollar[4].selectExprs, OrderBy: yyDollar[5].orderBy, Separator: yyDollar[6].str} } case 629: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4322 +//line sql.y:4322 { yyVAL.expr = &CaseExpr{Expr: yyDollar[2].expr, Whens: yyDollar[3].whens, Else: yyDollar[4].expr} } case 630: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4326 +//line sql.y:4326 { yyVAL.expr = &ValuesFuncExpr{Name: yyDollar[3].colIdent} } case 631: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4336 +//line sql.y:4336 { yyVAL.expr = &FuncExpr{Name: NewColIdent("current_timestamp")} } case 632: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4340 +//line sql.y:4340 { yyVAL.expr = &FuncExpr{Name: NewColIdent("utc_timestamp")} } case 633: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4344 +//line sql.y:4344 { yyVAL.expr = &FuncExpr{Name: NewColIdent("utc_time")} } case 634: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4348 +//line sql.y:4348 { yyVAL.expr = &FuncExpr{Name: NewColIdent("utc_date")} } case 635: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4353 +//line sql.y:4353 { yyVAL.expr = &FuncExpr{Name: NewColIdent("localtime")} } case 636: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4358 +//line sql.y:4358 { yyVAL.expr = &FuncExpr{Name: NewColIdent("localtimestamp")} } case 637: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4363 +//line sql.y:4363 { yyVAL.expr = &FuncExpr{Name: NewColIdent("current_date")} } case 638: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4368 +//line sql.y:4368 { yyVAL.expr = &FuncExpr{Name: NewColIdent("current_time")} } case 641: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4383 +//line sql.y:4383 { yyVAL.expr = &FuncExpr{Name: NewColIdent("if"), Exprs: yyDollar[3].selectExprs} } case 642: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4387 +//line sql.y:4387 { yyVAL.expr = &FuncExpr{Name: NewColIdent("database"), Exprs: yyDollar[3].selectExprs} } case 643: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4391 +//line sql.y:4391 { yyVAL.expr = &FuncExpr{Name: NewColIdent("mod"), Exprs: yyDollar[3].selectExprs} } case 644: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4395 +//line sql.y:4395 { yyVAL.expr = &FuncExpr{Name: NewColIdent("replace"), Exprs: yyDollar[3].selectExprs} } case 645: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4401 +//line sql.y:4401 { yyVAL.str = "" } case 646: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4405 +//line sql.y:4405 { yyVAL.str = BooleanModeStr } case 647: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4409 +//line sql.y:4409 { yyVAL.str = NaturalLanguageModeStr } case 648: yyDollar = yyS[yypt-7 : yypt+1] - //line sql.y:4413 +//line sql.y:4413 { yyVAL.str = NaturalLanguageModeWithQueryExpansionStr } case 649: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4417 +//line sql.y:4417 { yyVAL.str = QueryExpansionStr } case 650: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4423 +//line sql.y:4423 { yyVAL.str = string(yyDollar[1].bytes) } case 651: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4427 +//line sql.y:4427 { yyVAL.str = string(yyDollar[1].bytes) } case 652: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4433 +//line sql.y:4433 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 653: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4437 +//line sql.y:4437 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal, Charset: yyDollar[3].str, Operator: CharacterSetStr} } case 654: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4441 +//line sql.y:4441 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal, Charset: string(yyDollar[3].bytes)} } case 655: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4445 +//line sql.y:4445 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 656: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4449 +//line sql.y:4449 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 657: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4453 +//line sql.y:4453 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} yyVAL.convertType.Length = yyDollar[2].lengthScaleOption.Length @@ -7398,163 +7401,163 @@ yydefault: } case 658: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4459 +//line sql.y:4459 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 659: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4463 +//line sql.y:4463 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 660: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4467 +//line sql.y:4467 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 661: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4471 +//line sql.y:4471 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 662: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4475 +//line sql.y:4475 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes), Length: yyDollar[2].optVal} } case 663: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4479 +//line sql.y:4479 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 664: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4483 +//line sql.y:4483 { yyVAL.convertType = &ConvertType{Type: string(yyDollar[1].bytes)} } case 665: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4488 +//line sql.y:4488 { yyVAL.expr = nil } case 666: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4492 +//line sql.y:4492 { yyVAL.expr = yyDollar[1].expr } case 667: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4497 +//line sql.y:4497 { yyVAL.str = string("") } case 668: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4501 +//line sql.y:4501 { yyVAL.str = " separator '" + string(yyDollar[2].bytes) + "'" } case 669: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4507 +//line sql.y:4507 { yyVAL.whens = []*When{yyDollar[1].when} } case 670: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4511 +//line sql.y:4511 { yyVAL.whens = append(yyDollar[1].whens, yyDollar[2].when) } case 671: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4517 +//line sql.y:4517 { yyVAL.when = &When{Cond: yyDollar[2].expr, Val: yyDollar[4].expr} } case 672: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4522 +//line sql.y:4522 { yyVAL.expr = nil } case 673: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4526 +//line sql.y:4526 { yyVAL.expr = yyDollar[2].expr } case 674: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4532 +//line sql.y:4532 { yyVAL.colName = &ColName{Name: yyDollar[1].colIdent} } case 675: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4536 +//line sql.y:4536 { yyVAL.colName = &ColName{Qualifier: TableName{Name: yyDollar[1].tableIdent}, Name: yyDollar[3].colIdent} } case 676: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4540 +//line sql.y:4540 { yyVAL.colName = &ColName{Qualifier: TableName{Qualifier: yyDollar[1].tableIdent, Name: yyDollar[3].tableIdent}, Name: yyDollar[5].colIdent} } case 677: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4546 +//line sql.y:4546 { yyVAL.expr = NewStrVal(yyDollar[1].bytes) } case 678: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4550 +//line sql.y:4550 { yyVAL.expr = NewHexVal(yyDollar[1].bytes) } case 679: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4554 +//line sql.y:4554 { yyVAL.expr = NewIntVal(yyDollar[1].bytes) } case 680: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4558 +//line sql.y:4558 { yyVAL.expr = NewFloatVal(yyDollar[1].bytes) } case 681: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4562 +//line sql.y:4562 { yyVAL.expr = NewHexNum(yyDollar[1].bytes) } case 682: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4566 +//line sql.y:4566 { yyVAL.expr = NewValArg(yyDollar[1].bytes) } case 683: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4570 +//line sql.y:4570 { yyVAL.expr = &NullVal{} } case 684: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4576 +//line sql.y:4576 { // TODO(sougou): Deprecate this construct. if yyDollar[1].colIdent.Lowered() != "value" { @@ -7565,237 +7568,237 @@ yydefault: } case 685: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4585 +//line sql.y:4585 { yyVAL.expr = NewIntVal(yyDollar[1].bytes) } case 686: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4589 +//line sql.y:4589 { yyVAL.expr = NewValArg(yyDollar[1].bytes) } case 687: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4594 +//line sql.y:4594 { yyVAL.exprs = nil } case 688: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4598 +//line sql.y:4598 { yyVAL.exprs = yyDollar[3].exprs } case 689: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4603 +//line sql.y:4603 { yyVAL.expr = nil } case 690: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4607 +//line sql.y:4607 { yyVAL.expr = yyDollar[2].expr } case 691: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4612 +//line sql.y:4612 { yyVAL.orderBy = nil } case 692: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4616 +//line sql.y:4616 { yyVAL.orderBy = yyDollar[3].orderBy } case 693: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4622 +//line sql.y:4622 { yyVAL.orderBy = OrderBy{yyDollar[1].order} } case 694: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4626 +//line sql.y:4626 { yyVAL.orderBy = append(yyDollar[1].orderBy, yyDollar[3].order) } case 695: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4632 +//line sql.y:4632 { yyVAL.order = &Order{Expr: yyDollar[1].expr, Direction: yyDollar[2].str} } case 696: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4637 +//line sql.y:4637 { yyVAL.str = AscScr } case 697: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4641 +//line sql.y:4641 { yyVAL.str = AscScr } case 698: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4645 +//line sql.y:4645 { yyVAL.str = DescScr } case 699: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4650 +//line sql.y:4650 { yyVAL.limit = nil } case 700: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4654 +//line sql.y:4654 { yyVAL.limit = &Limit{Rowcount: yyDollar[2].expr} } case 701: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4658 +//line sql.y:4658 { yyVAL.limit = &Limit{Offset: yyDollar[2].expr, Rowcount: yyDollar[4].expr} } case 702: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4662 +//line sql.y:4662 { yyVAL.limit = &Limit{Offset: yyDollar[4].expr, Rowcount: yyDollar[2].expr} } case 703: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4667 +//line sql.y:4667 { yyVAL.str = "" } case 704: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4671 +//line sql.y:4671 { yyVAL.str = ForUpdateStr } case 705: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4675 +//line sql.y:4675 { yyVAL.str = ShareModeStr } case 706: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4688 +//line sql.y:4688 { yyVAL.ins = &Insert{Rows: yyDollar[2].values} } case 707: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4692 +//line sql.y:4692 { yyVAL.ins = &Insert{Rows: yyDollar[1].selStmt} } case 708: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4696 +//line sql.y:4696 { // Drop the redundant parenthesis. yyVAL.ins = &Insert{Rows: yyDollar[2].selStmt} } case 709: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4701 +//line sql.y:4701 { yyVAL.ins = &Insert{Columns: yyDollar[2].columns, Rows: yyDollar[5].values} } case 710: yyDollar = yyS[yypt-4 : yypt+1] - //line sql.y:4705 +//line sql.y:4705 { yyVAL.ins = &Insert{Columns: yyDollar[2].columns, Rows: yyDollar[4].selStmt} } case 711: yyDollar = yyS[yypt-6 : yypt+1] - //line sql.y:4709 +//line sql.y:4709 { // Drop the redundant parenthesis. yyVAL.ins = &Insert{Columns: yyDollar[2].columns, Rows: yyDollar[5].selStmt} } case 712: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4716 +//line sql.y:4716 { yyVAL.columns = Columns{yyDollar[1].colIdent} } case 713: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4720 +//line sql.y:4720 { yyVAL.columns = Columns{yyDollar[3].colIdent} } case 714: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4724 +//line sql.y:4724 { yyVAL.columns = append(yyVAL.columns, yyDollar[3].colIdent) } case 715: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4728 +//line sql.y:4728 { yyVAL.columns = append(yyVAL.columns, yyDollar[5].colIdent) } case 716: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4733 +//line sql.y:4733 { yyVAL.updateExprs = nil } case 717: yyDollar = yyS[yypt-5 : yypt+1] - //line sql.y:4737 +//line sql.y:4737 { yyVAL.updateExprs = yyDollar[5].updateExprs } case 718: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4743 +//line sql.y:4743 { yyVAL.values = Values{yyDollar[1].valTuple} } case 719: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4747 +//line sql.y:4747 { yyVAL.values = append(yyDollar[1].values, yyDollar[3].valTuple) } case 720: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4753 +//line sql.y:4753 { yyVAL.valTuple = yyDollar[1].valTuple } case 721: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4757 +//line sql.y:4757 { yyVAL.valTuple = ValTuple{} } case 722: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4763 +//line sql.y:4763 { yyVAL.valTuple = ValTuple(yyDollar[2].exprs) } case 723: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4769 +//line sql.y:4769 { if len(yyDollar[1].valTuple) == 1 { yyVAL.expr = &ParenExpr{yyDollar[1].valTuple[0]} @@ -7805,398 +7808,398 @@ yydefault: } case 724: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4779 +//line sql.y:4779 { yyVAL.updateExprs = UpdateExprs{yyDollar[1].updateExpr} } case 725: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4783 +//line sql.y:4783 { yyVAL.updateExprs = append(yyDollar[1].updateExprs, yyDollar[3].updateExpr) } case 726: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4789 +//line sql.y:4789 { yyVAL.updateExpr = &UpdateExpr{Name: yyDollar[1].colName, Expr: yyDollar[3].expr} } case 727: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4795 +//line sql.y:4795 { yyVAL.setExprs = SetExprs{yyDollar[1].setExpr} } case 728: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4799 +//line sql.y:4799 { yyVAL.setExprs = append(yyDollar[1].setExprs, yyDollar[3].setExpr) } case 729: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4805 +//line sql.y:4805 { yyVAL.setExpr = yyDollar[1].setExpr } case 730: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4809 +//line sql.y:4809 { yyDollar[2].setExpr.Scope = yyDollar[1].str yyVAL.setExpr = yyDollar[2].setExpr } case 731: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4816 +//line sql.y:4816 { yyVAL.setExpr = &SetExpr{Type: yyDollar[1].colIdent, Val: &OptVal{Value: NewStrVal([]byte("on"))}} } case 732: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4820 +//line sql.y:4820 { yyVAL.setExpr = &SetExpr{Type: yyDollar[1].colIdent, Val: &OptVal{Value: NewStrVal([]byte("off"))}} } case 733: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4824 +//line sql.y:4824 { yyVAL.setExpr = &SetExpr{Type: yyDollar[1].colIdent, Val: &OptVal{Value: yyDollar[3].expr}} } case 734: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4828 +//line sql.y:4828 { yyVAL.setExpr = &SetExpr{Type: NewColIdent(string(yyDollar[1].bytes)), Val: &OptVal{Value: yyDollar[2].expr}} } case 735: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4832 +//line sql.y:4832 { yyVAL.setExpr = &SetExpr{Type: NewColIdent(string(yyDollar[1].bytes)), Val: &OptVal{Value: &CollateExpr{Expr: yyDollar[2].expr, Charset: yyDollar[3].str}}} } case 737: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4839 +//line sql.y:4839 { yyVAL.bytes = []byte("charset") } case 738: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4845 +//line sql.y:4845 { yyVAL.expr = NewStrVal([]byte(yyDollar[1].colIdent.String())) } case 739: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4849 +//line sql.y:4849 { yyVAL.expr = NewStrVal(yyDollar[1].bytes) } case 740: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4853 +//line sql.y:4853 { yyVAL.expr = &Default{} } case 741: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4859 +//line sql.y:4859 { yyVAL.setExprs = SetExprs{&SetExpr{Type: NewColIdent(string(yyDollar[1].bytes)), Val: yyDollar[2].setVal}} } case 742: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4863 +//line sql.y:4863 { yyVAL.setExprs = SetExprs{&SetExpr{Scope: yyDollar[1].str, Type: NewColIdent(string(yyDollar[2].bytes)), Val: yyDollar[3].setVal}} } case 743: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4869 +//line sql.y:4869 { yyVAL.setVal = &TxnVal{Level: yyDollar[1].str, Mode: yyDollar[2].str} } case 744: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4873 +//line sql.y:4873 { yyVAL.setVal = &TxnVal{Level: yyDollar[2].str, Mode: yyDollar[1].str} } case 745: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4879 +//line sql.y:4879 { yyVAL.str = "" } case 746: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4883 +//line sql.y:4883 { yyVAL.str = yyDollar[2].str } case 747: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4889 +//line sql.y:4889 { yyVAL.str = yyDollar[3].str } case 748: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4895 +//line sql.y:4895 { yyVAL.str = RepeatableRead } case 749: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4899 +//line sql.y:4899 { yyVAL.str = ReadCommitted } case 750: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4903 +//line sql.y:4903 { yyVAL.str = ReadUncommitted } case 751: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4907 +//line sql.y:4907 { yyVAL.str = Serializable } case 752: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4913 +//line sql.y:4913 { yyVAL.str = "" } case 753: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4917 +//line sql.y:4917 { yyVAL.str = yyDollar[2].str } case 754: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4923 +//line sql.y:4923 { yyVAL.str = TxReadWrite } case 755: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4927 +//line sql.y:4927 { yyVAL.str = TxReadOnly } case 756: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4933 +//line sql.y:4933 { yyVAL.str = SessionStr } case 757: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4937 +//line sql.y:4937 { yyVAL.str = SessionStr } case 758: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4941 +//line sql.y:4941 { yyVAL.str = GlobalStr } case 761: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4950 +//line sql.y:4950 { yyVAL.byt = 0 } case 762: yyDollar = yyS[yypt-2 : yypt+1] - //line sql.y:4954 +//line sql.y:4954 { yyVAL.byt = 1 } case 763: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4959 +//line sql.y:4959 { yyVAL.byt = 0 } case 764: yyDollar = yyS[yypt-3 : yypt+1] - //line sql.y:4963 +//line sql.y:4963 { yyVAL.byt = 1 } case 765: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:4968 +//line sql.y:4968 { yyVAL.str = "" } case 766: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4972 +//line sql.y:4972 { yyVAL.str = IgnoreStr } case 767: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4978 +//line sql.y:4978 { yyVAL.empty = struct{}{} } case 768: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4982 +//line sql.y:4982 { yyVAL.empty = struct{}{} } case 769: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4986 +//line sql.y:4986 { yyVAL.empty = struct{}{} } case 770: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4990 +//line sql.y:4990 { yyVAL.empty = struct{}{} } case 771: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4994 +//line sql.y:4994 { yyVAL.empty = struct{}{} } case 772: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:4998 +//line sql.y:4998 { yyVAL.empty = struct{}{} } case 773: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5002 +//line sql.y:5002 { yyVAL.empty = struct{}{} } case 774: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5006 +//line sql.y:5006 { yyVAL.empty = struct{}{} } case 775: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5010 +//line sql.y:5010 { yyVAL.empty = struct{}{} } case 776: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5014 +//line sql.y:5014 { yyVAL.empty = struct{}{} } case 777: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:5019 +//line sql.y:5019 { yyVAL.empty = struct{}{} } case 778: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5023 +//line sql.y:5023 { yyVAL.empty = struct{}{} } case 779: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5027 +//line sql.y:5027 { yyVAL.empty = struct{}{} } case 780: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5033 +//line sql.y:5033 { yyVAL.empty = struct{}{} } case 781: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5037 +//line sql.y:5037 { yyVAL.empty = struct{}{} } case 782: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:5042 +//line sql.y:5042 { yyVAL.str = IndexStr } case 783: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5046 +//line sql.y:5046 { yyVAL.str = UniqueStr } case 784: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5052 +//line sql.y:5052 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 785: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5056 +//line sql.y:5056 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 787: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5063 +//line sql.y:5063 { yyVAL.colIdent = NewColIdent(string(yyDollar[1].bytes)) } case 788: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5069 +//line sql.y:5069 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 789: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5073 +//line sql.y:5073 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 791: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5080 +//line sql.y:5080 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 792: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5086 +//line sql.y:5086 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 793: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5090 +//line sql.y:5090 { yyVAL.tableIdent = NewTableIdent(string(yyDollar[1].bytes)) } case 1005: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5328 +//line sql.y:5328 { if incNesting(yylex) { yylex.Error("max nesting level reached") @@ -8205,13 +8208,13 @@ yydefault: } case 1006: yyDollar = yyS[yypt-1 : yypt+1] - //line sql.y:5337 +//line sql.y:5337 { decNesting(yylex) } case 1007: yyDollar = yyS[yypt-0 : yypt+1] - //line sql.y:5342 +//line sql.y:5342 { forceEOF(yylex) } diff --git a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.y b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.y index b7b73db7..e5a4473f 100644 --- a/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.y +++ b/src/vendor/github.com/xelabs/go-mysqlstack/sqlparser/sql.y @@ -706,7 +706,6 @@ func forceEOF(yylex interface{}) { %type columns_or_fields - database_from_opt from_or_in full_opt index_symbols @@ -905,6 +904,7 @@ func forceEOF(yylex interface{}) { as_opt_id db_name db_name_or_empty + database_from_opt %type as_opt @@ -3377,7 +3377,7 @@ show_statement: } | SHOW CREATE DATABASE table_id force_eof { - $$ = &Show{Type: ShowCreateDatabaseStr, Database: $4.v} + $$ = &Show{Type: ShowCreateDatabaseStr, Database: $4} } | SHOW DATABASES force_eof { @@ -3393,8 +3393,8 @@ show_statement: } | SHOW index_symbols from_or_in table_name database_from_opt where_expression_opt { - if $5 != ""{ - $4.Qualifier.v = $5 + if $5.v != ""{ + $4.Qualifier = $5 } var filter *ShowFilter if $6 != nil{ @@ -3404,8 +3404,8 @@ show_statement: } | SHOW full_opt columns_or_fields from_or_in table_name database_from_opt like_or_where_opt { - if $6 != ""{ - $5.Qualifier.v = $6 + if $6.v != ""{ + $5.Qualifier = $6 } $$ = &Show{Full: $2, Type: ShowColumnsStr, Table: $5, Filter: $7} } @@ -3480,11 +3480,11 @@ index_symbols: database_from_opt: /* empty */ { - $$ = "" + $$ = NewTableIdent("") } | from_or_in table_id { - $$ = $2.v + $$ = $2 } from_or_in: From 1bdd2f4a8b6ad67fcf72f8f1c77d706a680e3109 Mon Sep 17 00:00:00 2001 From: zhyass <34016424+zhyass@users.noreply.github.com> Date: Thu, 28 Jan 2021 11:23:32 +0800 Subject: [PATCH 2/2] *: change LowerCaseTableNames type to int and add some test cases #725 [summary] 1.lower-case-table-names: If set 0, table names are stored as specified and comparisons are case-sensitive. If set 1, table names are stored in lowercase on disk and comparisons are not case-sensitive. 2.Add some test cases. [test case] src/ctl/v1/radon_test.go src/proxy/initdb_test.go src/proxy/proxy_test.go src/proxy/query_test.go [patch codecov] src/ctl/v1/radon.go 92.8% src/proxy/proxy.go 86.5% src/proxy/spanner.go 95.2% --- docs/api.md | 2 +- intergration/radon-test/r/select.result | 9 ++ intergration/radon-test/t/select.test | 3 + src/config/config.go | 29 +++--- src/ctl/v1/radon.go | 2 +- src/ctl/v1/radon_test.go | 6 +- src/proxy/initdb_test.go | 2 +- src/proxy/proxy.go | 2 +- src/proxy/proxy_test.go | 8 +- src/proxy/query_test.go | 115 +++++++++++++++++++++++- src/proxy/spanner.go | 5 +- 11 files changed, 155 insertions(+), 28 deletions(-) diff --git a/docs/api.md b/docs/api.md index 265d48e5..66074bdc 100644 --- a/docs/api.md +++ b/docs/api.md @@ -65,7 +65,7 @@ Request: { "audit-mode": The audit log mode, "N": disabled, "R": read enabled, "W": write enabled, "A": read/write enabled, "blocks-readonly": The size of a block when create hash tables, "load-balance": Enables(0 or 1) load balance, for read-write separation, - "lower-case-table-names": If set false, table names are stored as specified and comparisons are case-sensitive, else not case-sensitive. + "lower-case-table-names": If set 0, table names are stored as specified and comparisons are case-sensitive. If set 1, not case-sensitive. } ``` diff --git a/intergration/radon-test/r/select.result b/intergration/radon-test/r/select.result index 3a7dbe9f..8b68788f 100644 --- a/intergration/radon-test/r/select.result +++ b/intergration/radon-test/r/select.result @@ -29,6 +29,15 @@ sum(a) b select c from integrate_test.t; ERROR 1054 (42S22): Unknown column 'c' in 'field list' +select a from integrate_test.T; +ERROR 1146 (42S02): Table 'T' doesn't exist + +select a from INTEGRATE_TEST.t; +ERROR 1146 (42S02): Table 'INTEGRATE_TEST.t' doesn't exist + +select tt.a from integrate_test.t as TT; +ERROR 1105 (HY000): unsupported: unknown.column.'tt.a'.in.field.list + create table integrate_test.s(a int key, b int) ENGINE=InnoDB DEFAULT CHARSET=utf8; diff --git a/intergration/radon-test/t/select.test b/intergration/radon-test/t/select.test index e2a29505..41de99b5 100644 --- a/intergration/radon-test/t/select.test +++ b/intergration/radon-test/t/select.test @@ -8,6 +8,9 @@ select a, b c from integrate_test.t where a in (0,1,2) order by C desc; select a, b from integrate_test.t where A>0; select sum(a), b from integrate_test.t where a>=0 group by B; select c from integrate_test.t; +select a from integrate_test.T; +select a from INTEGRATE_TEST.t; +select tt.a from integrate_test.t as TT; create table integrate_test.s(a int key, b int) ENGINE=InnoDB DEFAULT CHARSET=utf8; insert into integrate_test.s(a, b) values(0,1), (2,2); diff --git a/src/config/config.go b/src/config/config.go index 4fff7ce6..4553b7aa 100644 --- a/src/config/config.go +++ b/src/config/config.go @@ -28,8 +28,8 @@ type ProxyConfig struct { MetaDir string `json:"meta-dir"` Endpoint string `json:"endpoint"` TwopcEnable bool `json:"twopc-enable"` - LoadBalance int `json:"load-balance"` // 0 -- disable balance, 1 -- enable balance to replica - LowerCaseTableNames bool `json:"lower-case-table-names"` + LoadBalance int `json:"load-balance"` // 0 -- disable balance, 1 -- enable balance to replica + LowerCaseTableNames int `json:"lower-case-table-names"` // 0 -- case sensitive, 1 -- case insensitive MaxConnections int `json:"max-connections"` MaxResultSize int `json:"max-result-size"` @@ -49,18 +49,19 @@ type ProxyConfig struct { // DefaultProxyConfig returns default proxy config. func DefaultProxyConfig() *ProxyConfig { return &ProxyConfig{ - MetaDir: "./radon-meta", - Endpoint: "127.0.0.1:3308", - LoadBalance: 0, - MaxConnections: 1024, - MaxResultSize: 1024 * 1024 * 1024, // 1GB - MaxJoinRows: 32768, - DDLTimeout: 10 * 3600 * 1000, // 10hours - QueryTimeout: 5 * 60 * 1000, // 5minutes - PeerAddress: "127.0.0.1:8080", - LongQueryTime: 5, // 5 seconds - StreamBufferSize: 1024 * 1024 * 32, // 32MB - IdleTxnTimeout: 60, // 60 seconds + MetaDir: "./radon-meta", + Endpoint: "127.0.0.1:3308", + LoadBalance: 0, + LowerCaseTableNames: 0, + MaxConnections: 1024, + MaxResultSize: 1024 * 1024 * 1024, // 1GB + MaxJoinRows: 32768, + DDLTimeout: 10 * 3600 * 1000, // 10hours + QueryTimeout: 5 * 60 * 1000, // 5minutes + PeerAddress: "127.0.0.1:8080", + LongQueryTime: 5, // 5 seconds + StreamBufferSize: 1024 * 1024 * 32, // 32MB + IdleTxnTimeout: 60, // 60 seconds } } diff --git a/src/ctl/v1/radon.go b/src/ctl/v1/radon.go index ce5533f1..1b089ff0 100644 --- a/src/ctl/v1/radon.go +++ b/src/ctl/v1/radon.go @@ -29,7 +29,7 @@ type radonParams struct { AuditMode *string `json:"audit-mode"` StreamBufferSize *int `json:"stream-buffer-size"` Blocks *int `json:"blocks-readonly"` - LowerCaseTableNames *bool `json:"lower-case-table-names"` + LowerCaseTableNames *int `json:"lower-case-table-names"` } // RadonConfigHandler impl. diff --git a/src/ctl/v1/radon_test.go b/src/ctl/v1/radon_test.go index 1ff512ed..8cb262c0 100644 --- a/src/ctl/v1/radon_test.go +++ b/src/ctl/v1/radon_test.go @@ -47,7 +47,7 @@ func TestCtlV1RadonConfig(t *testing.T) { AuditMode string `json:"audit-mode"` StreamBufferSize int `json:"stream-buffer-size"` Blocks int `json:"blocks-readonly"` - LowerCaseTableNames bool `json:"lower-case-table-names"` + LowerCaseTableNames int `json:"lower-case-table-names"` } // 200. @@ -64,7 +64,7 @@ func TestCtlV1RadonConfig(t *testing.T) { AuditMode: "A", StreamBufferSize: 16777216, Blocks: 128, - LowerCaseTableNames: true, + LowerCaseTableNames: 1, } recorded := test.RunRequest(t, handler, test.MakeSimpleRequest("PUT", "http://localhost/v1/radon/config", p)) recorded.CodeIs(200) @@ -81,7 +81,7 @@ func TestCtlV1RadonConfig(t *testing.T) { assert.Equal(t, "A", radonConf.Audit.Mode) assert.Equal(t, 16777216, radonConf.Proxy.StreamBufferSize) assert.Equal(t, 128, radonConf.Router.Blocks) - assert.Equal(t, true, radonConf.Proxy.LowerCaseTableNames) + assert.Equal(t, 1, radonConf.Proxy.LowerCaseTableNames) } // Unset AllowIP. diff --git a/src/proxy/initdb_test.go b/src/proxy/initdb_test.go index ddb4d79a..4cf91d50 100644 --- a/src/proxy/initdb_test.go +++ b/src/proxy/initdb_test.go @@ -42,7 +42,7 @@ func TestProxyUseDatabase(t *testing.T) { spanner.ComInitDB(session, "TEST") assert.Equal(t, "TEST", session.Schema()) - proxy.SetLowerCaseTableNames(true) + proxy.SetLowerCaseTableNames(1) spanner.ComInitDB(session, "TEST") assert.Equal(t, "test", session.Schema()) } diff --git a/src/proxy/proxy.go b/src/proxy/proxy.go index e3df9639..8d0f03b0 100644 --- a/src/proxy/proxy.go +++ b/src/proxy/proxy.go @@ -316,7 +316,7 @@ func (p *Proxy) SetBlocks(blocks int) { } // SetLowerCaseTableNames used to set LowerCaseTableNames to false or true. -func (p *Proxy) SetLowerCaseTableNames(lowerCase bool) { +func (p *Proxy) SetLowerCaseTableNames(lowerCase int) { p.mu.Lock() defer p.mu.Unlock() p.log.Info("proxy.SetLowerCaseTableNames:[%v->%v]", p.conf.Proxy.LowerCaseTableNames, lowerCase) diff --git a/src/proxy/proxy_test.go b/src/proxy/proxy_test.go index cb266500..9c268461 100644 --- a/src/proxy/proxy_test.go +++ b/src/proxy/proxy_test.go @@ -107,10 +107,10 @@ func TestProxy1(t *testing.T) { // SetLowerCaseTableNames. { - proxy.SetLowerCaseTableNames(true) - assert.Equal(t, true, proxy.conf.Proxy.LowerCaseTableNames) - proxy.SetLowerCaseTableNames(false) - assert.Equal(t, false, proxy.conf.Proxy.LowerCaseTableNames) + proxy.SetLowerCaseTableNames(1) + assert.Equal(t, 1, proxy.conf.Proxy.LowerCaseTableNames) + proxy.SetLowerCaseTableNames(0) + assert.Equal(t, 0, proxy.conf.Proxy.LowerCaseTableNames) } // FlushConfig. diff --git a/src/proxy/query_test.go b/src/proxy/query_test.go index 111f442a..18c717c1 100644 --- a/src/proxy/query_test.go +++ b/src/proxy/query_test.go @@ -739,18 +739,46 @@ func TestProxyLowerCase(t *testing.T) { fakedbs, proxy, cleanup := MockProxy(log) defer cleanup() address := proxy.Address() - proxy.SetLowerCaseTableNames(true) + + r1 := &sqltypes.Result{ + Fields: []*querypb.Field{ + { + Name: "table", + Type: querypb.Type_VARCHAR, + }, + { + Name: "create table", + Type: querypb.Type_VARCHAR, + }, + }, + Rows: [][]sqltypes.Value{ + { + sqltypes.MakeTrusted(querypb.Type_VARCHAR, []byte("t1")), + sqltypes.MakeTrusted(querypb.Type_VARCHAR, []byte("create table t1")), + }, + }, + } // fakedbs. { fakedbs.AddQueryPattern("create .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("insert .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("delete .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("update .*", &sqltypes.Result{}) fakedbs.AddQueryPattern("select .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("use .*", &sqltypes.Result{}) + fakedbs.AddQueryPattern("show create .*", r1) + } + + { + proxy.SetLowerCaseTableNames(1) } // create database. { client, err := driver.NewConn("mock", "mock", address, "", "utf8") assert.Nil(t, err) + defer client.Close() query := "create database TEST" _, err = client.FetchAll(query, -1) assert.Nil(t, err) @@ -760,17 +788,100 @@ func TestProxyLowerCase(t *testing.T) { { client, err := driver.NewConn("mock", "mock", address, "", "utf8") assert.Nil(t, err) + defer client.Close() query := "create table test.T1(id int, b int) partition by hash(id)" _, err = client.FetchAll(query, -1) assert.Nil(t, err) } + // insert. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "insert into Test.t1(id,b) values(1,1)" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // update. + { + client, err := driver.NewConn("mock", "mock", address, "test", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "update t1 set b=2 where id=1" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // select. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "select * from tEst.t1 as T where t.b=2" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // delete. + { + client, err := driver.NewConn("mock", "mock", address, "TEST", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "delete from t1 where T1.id=1" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // show. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "show create table test.t1" + _, err = client.FetchAll(query, -1) + assert.Nil(t, err) + } + + // lower_case_table_names=0 + { + proxy.SetLowerCaseTableNames(0) + } + // select. { client, err := driver.NewConn("mock", "mock", address, "", "utf8") assert.Nil(t, err) - query := "select * from test.t1" + defer client.Close() + query := "select * from test.t1 as t where t.b=2" _, err = client.FetchAll(query, -1) assert.Nil(t, err) } + + // select error 1. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "select * from TEST.T1 as t where t.b=2" + _, err = client.FetchAll(query, -1) + assert.NotNil(t, err) + want := "Table 'TEST.T1' doesn't exist (errno 1146) (sqlstate 42S02)" + got := err.Error() + assert.Equal(t, want, got) + } + + // select error 2. + { + client, err := driver.NewConn("mock", "mock", address, "", "utf8") + assert.Nil(t, err) + defer client.Close() + query := "select * from test.t1 as T where t.b=2" + _, err = client.FetchAll(query, -1) + assert.NotNil(t, err) + want := "unsupported: unknown.column.'t.b'.in.clause (errno 1105) (sqlstate HY000)" + got := err.Error() + assert.Equal(t, want, got) + } } diff --git a/src/proxy/spanner.go b/src/proxy/spanner.go index 5e3c9a72..488d0838 100644 --- a/src/proxy/spanner.go +++ b/src/proxy/spanner.go @@ -153,5 +153,8 @@ func (spanner *Spanner) isAutocommitFalseIsTxn() bool { } func (spanner *Spanner) isLowerCaseTableNames() bool { - return spanner.conf.Proxy.LowerCaseTableNames + if spanner.conf.Proxy.LowerCaseTableNames == 0 { + return false + } + return true }