text:
yypt-2].item.(*ast.TableName),
				NewTable: yyS[yypt-0].item.(*ast.TableName),
			}
		}
	case 72:
		{
			parser.yyVAL.statement = &ast.RecoverTableStmt{
				JobID: yyS[yypt-0].item.(int64),
			}
		}
	case 73:
		{
			parser.yyVAL.statement = &ast.RecoverTableStmt{
				Table: yyS[yypt-0].item.(*ast.TableName),
			}
		}
	case 74:
		{
			parser.yyVAL.statement = &ast.RecoverTableStmt{
				Table:  yyS[yypt-1].item.(*ast.TableName),
				JobNum: yyS[yypt-0].item.(int64),
			}
		}
	case 75:
		{
			parser.yyVAL.statement = &ast.SplitRegionStmt{
				Table:    yyS[yypt-1].item.(*ast.TableName),
				SplitOpt: yyS[yypt-0].item.(*ast.SplitOption),
			}
		}
	case 76:
		{
			parser.yyVAL.statement = &ast.SplitRegionStmt{
				Table:     yyS[yypt-3].item.(*ast.TableName),
				IndexName: model.NewCIStr(yyS[yypt-1].ident),
				SplitOpt:  yyS[yypt-0].item.(*ast.SplitOption),
			}
		}
	case 77:
		{
			parser.yyVAL.item = &ast.SplitOption{
				Lower: yyS[yypt-4].item.([]ast.ExprNode),
				Upper: yyS[yypt-2].item.([]ast.ExprNode),
				Num:   yyS[yypt-0].item.(int64),
			}
		}
	case 78:
		{
			parser.yyVAL.item = &ast.SplitOption{
				ValueLists: yyS[yypt-0].item.([][]ast.ExprNode),
			}
		}
	case 79:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{TableNames: yyS[yypt-1].item.([]*ast.TableName), AnalyzeOpts: yyS[yypt-0].item.([]ast.AnalyzeOpt)}
		}
	case 80:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{TableNames: []*ast.TableName{yyS[yypt-3].item.(*ast.TableName)}, IndexNames: yyS[yypt-1].item.([]model.CIStr), IndexFlag: true, AnalyzeOpts: yyS[yypt-0].item.([]ast.AnalyzeOpt)}
		}
	case 81:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{TableNames: []*ast.TableName{yyS[yypt-3].item.(*ast.TableName)}, IndexNames: yyS[yypt-1].item.([]model.CIStr), IndexFlag: true, Incremental: true, AnalyzeOpts: yyS[yypt-0].item.([]ast.AnalyzeOpt)}
		}
	case 82:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{TableNames: []*ast.TableName{yyS[yypt-3].item.(*ast.TableName)}, PartitionNames: yyS[yypt-1].item.([]model.CIStr), AnalyzeOpts: yyS[yypt-0].item.([]ast.AnalyzeOpt)}
		}
	case 83:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{
				TableNames:     []*ast.TableName{yyS[yypt-5].item.(*ast.TableName)},
				PartitionNames: yyS[yypt-3].item.([]model.CIStr),
				IndexNames:     yyS[yypt-1].item.([]model.CIStr),
				IndexFlag:      true,
				AnalyzeOpts:    yyS[yypt-0].item.([]ast.AnalyzeOpt),
			}
		}
	case 84:
		{
			parser.yyVAL.statement = &ast.AnalyzeTableStmt{
				TableNames:     []*ast.TableName{yyS[yypt-5].item.(*ast.TableName)},
				PartitionNames: yyS[yypt-3].item.([]model.CIStr),
				IndexNames:     yyS[yypt-1].item.([]model.CIStr),
				IndexFlag:      true,
				Incremental:    true,
				AnalyzeOpts:    yyS[yypt-0].item.([]ast.AnalyzeOpt),
			}
		}
	case 85:
		{
			parser.yyVAL.item = []ast.AnalyzeOpt{}
		}
	case 86:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]ast.AnalyzeOpt)
		}
	case 87:
		{
			parser.yyVAL.item = []ast.AnalyzeOpt{yyS[yypt-0].item.(ast.AnalyzeOpt)}
		}
	case 88:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.AnalyzeOpt), yyS[yypt-0].item.(ast.AnalyzeOpt))
		}
	case 89:
		{
			parser.yyVAL.item = ast.AnalyzeOpt{Type: ast.AnalyzeOptNumBuckets, Value: getUint64FromNUM(yyS[yypt-1].item)}
		}
	case 90:
		{
			parser.yyVAL.item = ast.AnalyzeOpt{Type: ast.AnalyzeOptNumTopN, Value: getUint64FromNUM(yyS[yypt-1].item)}
		}
	case 91:
		{
			parser.yyVAL.item = ast.AnalyzeOpt{Type: ast.AnalyzeOptCMSketchDepth, Value: getUint64FromNUM(yyS[yypt-2].item)}
		}
	case 92:
		{
			parser.yyVAL.item = ast.AnalyzeOpt{Type: ast.AnalyzeOptCMSketchWidth, Value: getUint64FromNUM(yyS[yypt-2].item)}
		}
	case 93:
		{
			parser.yyVAL.item = ast.AnalyzeOpt{Type: ast.AnalyzeOptNumSamples, Value: getUint64FromNUM(yyS[yypt-1].item)}
		}
	case 94:
		{
			parser.yyVAL.item = &ast.Assignment{Column: yyS[yypt-2].item.(*ast.ColumnName), Expr: yyS[yypt-0].expr}
		}
	case 95:
		{
			parser.yyVAL.item = []*ast.Assignment{yyS[yypt-0].item.(*ast.Assignment)}
		}
	case 96:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.Assignment), yyS[yypt-0].item.(*ast.Assignment))
		}
	case 97:
		{
			parser.yyVAL.item = []*ast.Assignment{}
		}
	case 99:
		{
			parser.yyVAL.statement = &ast.BeginStmt{}
		}
	case 100:
		{
			parser.yyVAL.statement = &ast.BeginStmt{
				Mode: ast.Pessimistic,
			}
		}
	case 101:
		{
			parser.yyVAL.statement = &ast.BeginStmt{
				Mode: ast.Optimistic,
			}
		}
	case 102:
		{
			parser.yyVAL.statement = &ast.BeginStmt{}
		}
	case 103:
		{
			parser.yyVAL.statement = &ast.BeginStmt{}
		}
	case 104:
		{
			parser.yyVAL.statement = &ast.BinlogStmt{Str: yyS[yypt-0].ident}
		}
	case 105:
		{
			parser.yyVAL.item = []*ast.ColumnDef{yyS[yypt-0].item.(*ast.ColumnDef)}
		}
	case 106:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.ColumnDef), yyS[yypt-0].item.(*ast.ColumnDef))
		}
	case 107:
		{
			colDef := &ast.ColumnDef{Name: yyS[yypt-2].item.(*ast.ColumnName), Tp: yyS[yypt-1].item.(*types.FieldType), Options: yyS[yypt-0].item.([]*ast.ColumnOption)}
			if !colDef.Validate() {
				yylex.AppendError(yylex.Errorf("Invalid column definition"))
				return 1
			}
			parser.yyVAL.item = colDef
		}
	case 108:
		{
			parser.yyVAL.item = &ast.ColumnName{Name: model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 109:
		{
			parser.yyVAL.item = &ast.ColumnName{Table: model.NewCIStr(yyS[yypt-2].ident), Name: model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 110:
		{
			parser.yyVAL.item = &ast.ColumnName{Schema: model.NewCIStr(yyS[yypt-4].ident), Table: model.NewCIStr(yyS[yypt-2].ident), Name: model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 111:
		{
			parser.yyVAL.item = []*ast.ColumnName{yyS[yypt-0].item.(*ast.ColumnName)}
		}
	case 112:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.ColumnName), yyS[yypt-0].item.(*ast.ColumnName))
		}
	case 113:
		{
			parser.yyVAL.item = []*ast.ColumnName{}
		}
	case 114:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]*ast.ColumnName)
		}
	case 115:
		{
			parser.yyVAL.item = []*ast.ColumnNameOrUserVar{}
		}
	case 116:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]*ast.ColumnNameOrUserVar)
		}
	case 117:
		{
			parser.yyVAL.item = []*ast.ColumnNameOrUserVar{yyS[yypt-0].item.(*ast.ColumnNameOrUserVar)}
		}
	case 118:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.ColumnNameOrUserVar), yyS[yypt-0].item.(*ast.ColumnNameOrUserVar))
		}
	case 119:
		{
			parser.yyVAL.item = &ast.ColumnNameOrUserVar{ColumnName: yyS[yypt-0].item.(*ast.ColumnName)}
		}
	case 120:
		{
			parser.yyVAL.item = &ast.ColumnNameOrUserVar{UserVar: yyS[yypt-0].expr.(*ast.VariableExpr)}
		}
	case 121:
		{
			parser.yyVAL.item = []*ast.ColumnNameOrUserVar{}
		}
	case 122:
		{
			parser.yyVAL.item = yyS[yypt-1].item.([]*ast.ColumnNameOrUserVar)
		}
	case 123:
		{
			parser.yyVAL.statement = &ast.CommitStmt{}
		}
	case 126:
		{
			parser.yyVAL.item = true
		}
	case 127:
		{
			parser.yyVAL.item = false
		}
	case 128:
		{
			parser.yyVAL.item = true
		}
	case 129:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 130:
		{
			parser.yyVAL.item = 0
		}
	case 131:
		{
			if yyS[yypt-0].item.(bool) {
				parser.yyVAL.item = 1
			} else {
				parser.yyVAL.item = 2
			}
		}
	case 132:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionNotNull}
		}
	case 133:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionNull}
		}
	case 134:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionAutoIncrement}
		}
	case 135:
		{
			// 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.
			// See http://dev.mysql.com/doc/refman/5.7/en/create-table.html
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionPrimaryKey}
		}
	case 136:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionUniqKey}
		}
	case 137:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionUniqKey}
		}
	case 138:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionDefaultValue, Expr: yyS[yypt-0].expr}
		}
	case 139:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionOnUpdate, Expr: yyS[yypt-0].expr}
		}
	case 140:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionComment, Expr: ast.NewValueExpr(yyS[yypt-0].ident)}
		}
	case 141:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/create-table.html
			// The CHECK clause is parsed but ignored by all storage engines.
			// See the branch named `EnforcedOrNotOrNotNullOpt`.

			optionCheck := &ast.ColumnOption{
				Tp:       ast.ColumnOptionCheck,
				Expr:     yyS[yypt-2].expr,
				Enforced: true,
			}
			switch yyS[yypt-0].item.(int) {
			case 0:
				parser.yyVAL.item = []*ast.ColumnOption{optionCheck, {Tp: ast.ColumnOptionNotNull}}
			case 1:
				optionCheck.Enforced = true
				parser.yyVAL.item = optionCheck
			case 2:
				optionCheck.Enforced = false
				parser.yyVAL.item = optionCheck
			default:
			}
			yylex.AppendError(yylex.Errorf("The CHECK clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 142:
		{
			startOffset := parser.startOffset(&yyS[yypt-2])
			endOffset := parser.endOffset(&yyS[yypt-1])
			expr := yyS[yypt-2].expr
			expr.SetText(parser.src[startOffset:endOffset])

			parser.yyVAL.item = &ast.ColumnOption{
				Tp:     ast.ColumnOptionGenerated,
				Expr:   expr,
				Stored: yyS[yypt-0].item.(bool),
			}
		}
	case 143:
		{
			parser.yyVAL.item = &ast.ColumnOption{
				Tp:    ast.ColumnOptionReference,
				Refer: yyS[yypt-0].item.(*ast.ReferenceDef),
			}
		}
	case 144:
		{
			parser.yyVAL.item = &ast.ColumnOption{Tp: ast.ColumnOptionCollate, StrValue: yyS[yypt-0].item.(string)}
		}
	case 147:
		{
			parser.yyVAL.item = false
		}
	case 148:
		{
			parser.yyVAL.item = false
		}
	case 149:
		{
			parser.yyVAL.item = true
		}
	case 150:
		{
			if columnOption, ok := yyS[yypt-0].item.(*ast.ColumnOption); ok {
				parser.yyVAL.item = []*ast.ColumnOption{columnOption}
			} else {
				parser.yyVAL.item = yyS[yypt-0].item
			}
		}
	case 151:
		{
			if columnOption, ok := yyS[yypt-0].item.(*ast.ColumnOption); ok {
				parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.ColumnOption), columnOption)
			} else {
				parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.ColumnOption), yyS[yypt-0].item.([]*ast.ColumnOption)...)
			}
		}
	case 152:
		{
			parser.yyVAL.item = []*ast.ColumnOption{}
		}
	case 153:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]*ast.ColumnOption)
		}
	case 154:
		{
			c := &ast.Constraint{
				Tp:   ast.ConstraintPrimaryKey,
				Keys: yyS[yypt-2].item.([]*ast.IndexColName),
			}
			if yyS[yypt-0].item != nil {
				c.Option = yyS[yypt-0].item.(*ast.IndexOption)
			}
			if yyS[yypt-4].item != nil {
				if c.Option == nil {
					c.Option = &ast.IndexOption{}
				}
				c.Option.Tp = yyS[yypt-4].item.(model.IndexType)
			}
			parser.yyVAL.item = c
		}
	case 155:
		{
			c := &ast.Constraint{
				Tp:   ast.ConstraintFulltext,
				Keys: yyS[yypt-2].item.([]*ast.IndexColName),
				Name: yyS[yypt-4].item.(string),
			}
			if yyS[yypt-0].item != nil {
				c.Option = yyS[yypt-0].item.(*ast.IndexOption)
			}
			parser.yyVAL.item = c
		}
	case 156:
		{
			c := &ast.Constraint{
				IfNotExists: yyS[yypt-6].item.(bool),
				Tp:          ast.ConstraintIndex,
				Keys:        yyS[yypt-2].item.([]*ast.IndexColName),
				Name:        yyS[yypt-5].item.(string),
			}
			if yyS[yypt-0].item != nil {
				c.Option = yyS[yypt-0].item.(*ast.IndexOption)
			}
			if yyS[yypt-4].item != nil {
				if c.Option == nil {
					c.Option = &ast.IndexOption{}
				}
				c.Option.Tp = yyS[yypt-4].item.(model.IndexType)
			}
			parser.yyVAL.item = c
		}
	case 157:
		{
			c := &ast.Constraint{
				Tp:   ast.ConstraintUniq,
				Keys: yyS[yypt-2].item.([]*ast.IndexColName),
				Name: yyS[yypt-5].item.(string),
			}
			if yyS[yypt-0].item != nil {
				c.Option = yyS[yypt-0].item.(*ast.IndexOption)
			}
			if yyS[yypt-4].item != nil {
				if c.Option == nil {
					c.Option = &ast.IndexOption{}
				}
				c.Option.Tp = yyS[yypt-4].item.(model.IndexType)
			}
			parser.yyVAL.item = c
		}
	case 158:
		{
			parser.yyVAL.item = &ast.Constraint{
				IfNotExists: yyS[yypt-5].item.(bool),
				Tp:          ast.ConstraintForeignKey,
				Keys:        yyS[yypt-2].item.([]*ast.IndexColName),
				Name:        yyS[yypt-4].item.(string),
				Refer:       yyS[yypt-0].item.(*ast.ReferenceDef),
			}
		}
	case 159:
		{
			parser.yyVAL.item = &ast.Constraint{
				Tp:       ast.ConstraintCheck,
				Expr:     yyS[yypt-2].expr.(ast.ExprNode),
				Enforced: yyS[yypt-0].item.(bool),
			}
			yylex.AppendError(yylex.Errorf("The CHECK clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 160:
		{
			parser.yyVAL.item = ast.MatchFull
		}
	case 161:
		{
			parser.yyVAL.item = ast.MatchPartial
		}
	case 162:
		{
			parser.yyVAL.item = ast.MatchSimple
		}
	case 163:
		{
			parser.yyVAL.item = ast.MatchNone
		}
	case 164:
		{
			parser.yyVAL.item = yyS[yypt-0].item
			yylex.AppendError(yylex.Errorf("The MATCH clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 165:
		{
			onDeleteUpdate := yyS[yypt-0].item.([2]interface{})
			parser.yyVAL.item = &ast.ReferenceDef{
				Table:         yyS[yypt-3].item.(*ast.TableName),
				IndexColNames: yyS[yypt-2].item.([]*ast.IndexColName),
				OnDelete:      onDeleteUpdate[0].(*ast.OnDeleteOpt),
				OnUpdate:      onDeleteUpdate[1].(*ast.OnUpdateOpt),
				Match:         yyS[yypt-1].item.(ast.MatchType),
			}
		}
	case 166:
		{
			parser.yyVAL.item = ([]*ast.IndexColName)(nil)
		}
	case 167:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 168:
		{
			parser.yyVAL.item = &ast.OnDeleteOpt{ReferOpt: yyS[yypt-0].item.(ast.ReferOptionType)}
		}
	case 169:
		{
			parser.yyVAL.item = &ast.OnUpdateOpt{ReferOpt: yyS[yypt-0].item.(ast.ReferOptionType)}
		}
	case 170:
		{
			parser.yyVAL.item = [2]interface{}{&ast.OnDeleteOpt{}, &ast.OnUpdateOpt{}}
		}
	case 171:
		{
			parser.yyVAL.item = [2]interface{}{yyS[yypt-0].item, &ast.OnUpdateOpt{}}
		}
	case 172:
		{
			parser.yyVAL.item = [2]interface{}{&ast.OnDeleteOpt{}, yyS[yypt-0].item}
		}
	case 173:
		{
			parser.yyVAL.item = [2]interface{}{yyS[yypt-1].item, yyS[yypt-0].item}
		}
	case 174:
		{
			parser.yyVAL.item = [2]interface{}{yyS[yypt-0].item, yyS[yypt-1].item}
		}
	case 175:
		{
			parser.yyVAL.item = ast.ReferOptionRestrict
		}
	case 176:
		{
			parser.yyVAL.item = ast.ReferOptionCascade
		}
	case 177:
		{
			parser.yyVAL.item = ast.ReferOptionSetNull
		}
	case 178:
		{
			parser.yyVAL.item = ast.ReferOptionNoAction
		}
	case 179:
		{
			parser.yyVAL.item = ast.ReferOptionSetDefault
			yylex.AppendError(yylex.Errorf("The SET DEFAULT clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 182:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr("CURRENT_TIMESTAMP")}
		}
	case 183:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr("CURRENT_TIMESTAMP")}
		}
	case 184:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr("CURRENT_TIMESTAMP"), Args: []ast.ExprNode{ast.NewValueExpr(yyS[yypt-1].item)}}
		}
	case 192:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].expr)
		}
	case 193:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Plus, V: ast.NewValueExpr(yyS[yypt-0].item)}
		}
	case 194:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Minus, V: ast.NewValueExpr(yyS[yypt-0].item)}
		}
	case 198:
		{
			var indexOption *ast.IndexOption
			if yyS[yypt-1].item != nil {
				indexOption = yyS[yypt-1].item.(*ast.IndexOption)
				if indexOption.Tp == model.IndexTypeInvalid {
					if yyS[yypt-7].item != nil {
						indexOption.Tp = yyS[yypt-7].item.(model.IndexType)
					}
				}
			} else {
				indexOption = &ast.IndexOption{}
				if yyS[yypt-7].item != nil {
					indexOption.Tp = yyS[yypt-7].item.(model.IndexType)
				}
			}
			parser.yyVAL.statement = &ast.CreateIndexStmt{
				Unique:        yyS[yypt-11].item.(bool),
				IfNotExists:   yyS[yypt-9].item.(bool),
				IndexName:     yyS[yypt-8].ident,
				Table:         yyS[yypt-5].item.(*ast.TableName),
				IndexColNames: yyS[yypt-3].item.([]*ast.IndexColName),
				IndexOption:   indexOption,
			}
		}
	case 199:
		{
			parser.yyVAL.item = false
		}
	case 200:
		{
			parser.yyVAL.item = true
		}
	case 201:
		{
			//Order is parsed but just ignored as MySQL did
			parser.yyVAL.item = &ast.IndexColName{Column: yyS[yypt-2].item.(*ast.ColumnName), Length: yyS[yypt-1].item.(int)}
		}
	case 202:
		{
			parser.yyVAL.item = []*ast.IndexColName{yyS[yypt-0].item.(*ast.IndexColName)}
		}
	case 203:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.IndexColName), yyS[yypt-0].item.(*ast.IndexColName))
		}
	case 204:
		{
			parser.yyVAL.statement = &ast.AlterDatabaseStmt{
				Name:                 yyS[yypt-1].item.(string),
				AlterDefaultDatabase: false,
				Options:              yyS[yypt-0].item.([]*ast.DatabaseOption),
			}
		}
	case 205:
		{
			parser.yyVAL.statement = &ast.AlterDatabaseStmt{
				Name:                 "",
				AlterDefaultDatabase: true,
				Options:              yyS[yypt-0].item.([]*ast.DatabaseOption),
			}
		}
	case 206:
		{
			parser.yyVAL.statement = &ast.CreateDatabaseStmt{
				IfNotExists: yyS[yypt-2].item.(bool),
				Name:        yyS[yypt-1].item.(string),
				Options:     yyS[yypt-0].item.([]*ast.DatabaseOption),
			}
		}
	case 207:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 208:
		{
			parser.yyVAL.item = &ast.DatabaseOption{Tp: ast.DatabaseOptionCharset, Value: yyS[yypt-0].item.(string)}
		}
	case 209:
		{
			parser.yyVAL.item = &ast.DatabaseOption{Tp: ast.DatabaseOptionCollate, Value: yyS[yypt-0].item.(string)}
		}
	case 210:
		{
			parser.yyVAL.item = &ast.DatabaseOption{Tp: ast.DatabaseOptionEncryption, Value: yyS[yypt-0].ident}
		}
	case 211:
		{
			parser.yyVAL.item = []*ast.DatabaseOption{}
		}
	case 213:
		{
			parser.yyVAL.item = []*ast.DatabaseOption{yyS[yypt-0].item.(*ast.DatabaseOption)}
		}
	case 214:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.DatabaseOption), yyS[yypt-0].item.(*ast.DatabaseOption))
		}
	case 215:
		{
			stmt := yyS[yypt-5].item.(*ast.CreateTableStmt)
			stmt.Table = yyS[yypt-6].item.(*ast.TableName)
			stmt.IfNotExists = yyS[yypt-7].item.(bool)
			stmt.IsTemporary = yyS[yypt-9].item.(bool)
			stmt.Options = yyS[yypt-4].item.([]*ast.TableOption)
			if yyS[yypt-3].item != nil {
				stmt.Partition = yyS[yypt-3].item.(*ast.PartitionOptions)
			}
			stmt.OnDuplicate = yyS[yypt-2].item.(ast.OnDuplicateKeyHandlingType)
			stmt.Select = yyS[yypt-0].item.(*ast.CreateTableStmt).Select
			parser.yyVAL.statement = stmt
		}
	case 216:
		{
			parser.yyVAL.statement = &ast.CreateTableStmt{
				Table:       yyS[yypt-1].item.(*ast.TableName),
				ReferTable:  yyS[yypt-0].item.(*ast.TableName),
				IfNotExists: yyS[yypt-2].item.(bool),
				IsTemporary: yyS[yypt-4].item.(bool),
			}
		}
	case 219:
		{
			parser.yyVAL.item = nil
		}
	case 220:
		{
			method := yyS[yypt-3].item.(*ast.PartitionMethod)
			method.Num = yyS[yypt-2].item.(uint64)
			sub, _ := yyS[yypt-1].item.(*ast.PartitionMethod)
			defs, _ := yyS[yypt-0].item.([]*ast.PartitionDefinition)
			opt := &ast.PartitionOptions{
				PartitionMethod: *method,
				Sub:             sub,
				Definitions:     defs,
			}
			if err := opt.Validate(); err != nil {
				yylex.AppendError(err)
				return 1
			}
			parser.yyVAL.item = opt
		}
	case 221:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:          model.PartitionTypeKey,
				Linear:      len(yyS[yypt-5].ident) != 0,
				ColumnNames: yyS[yypt-1].item.([]*ast.ColumnName),
			}
		}
	case 222:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:     model.PartitionTypeHash,
				Linear: len(yyS[yypt-4].ident) != 0,
				Expr:   yyS[yypt-1].expr.(ast.ExprNode),
			}
		}
	case 225:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 226:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:   model.PartitionTypeRange,
				Expr: yyS[yypt-1].expr.(ast.ExprNode),
			}
		}
	case 227:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:          model.PartitionTypeRange,
				ColumnNames: yyS[yypt-1].item.([]*ast.ColumnName),
			}
		}
	case 228:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:   model.PartitionTypeList,
				Expr: yyS[yypt-1].expr.(ast.ExprNode),
			}
		}
	case 229:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:          model.PartitionTypeList,
				ColumnNames: yyS[yypt-1].item.([]*ast.ColumnName),
			}
		}
	case 230:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:   model.PartitionTypeSystemTime,
				Expr: yyS[yypt-1].expr.(ast.ExprNode),
				Unit: yyS[yypt-0].item.(ast.TimeUnitType),
			}
		}
	case 231:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp:    model.PartitionTypeSystemTime,
				Limit: yyS[yypt-0].item.(uint64),
			}
		}
	case 232:
		{
			parser.yyVAL.item = &ast.PartitionMethod{
				Tp: model.PartitionTypeSystemTime,
			}
		}
	case 233:
		{
			parser.yyVAL.ident = ""
		}
	case 234:
		{
			parser.yyVAL.ident = yyS[yypt-0].ident
		}
	case 235:
		{
			parser.yyVAL.item = nil
		}
	case 236:
		{
			method := yyS[yypt-1].item.(*ast.PartitionMethod)
			method.Num = yyS[yypt-0].item.(uint64)
			parser.yyVAL.item = method
		}
	case 237:
		{
			parser.yyVAL.item = uint64(0)
		}
	case 238:
		{
			res := yyS[yypt-0].item.(uint64)
			if res == 0 {
				yylex.AppendError(ast.ErrNoParts.GenWithStackByArgs("subpartitions"))
				return 1
			}
			parser.yyVAL.item = res
		}
	case 239:
		{
			parser.yyVAL.item = uint64(0)
		}
	case 240:
		{
			res := yyS[yypt-0].item.(uint64)
			if res == 0 {
				yylex.AppendError(ast.ErrNoParts.GenWithStackByArgs("partitions"))
				return 1
			}
			parser.yyVAL.item = res
		}
	case 241:
		{
			parser.yyVAL.item = nil
		}
	case 242:
		{
			parser.yyVAL.item = yyS[yypt-1].item.([]*ast.PartitionDefinition)
		}
	case 243:
		{
			parser.yyVAL.item = []*ast.PartitionDefinition{yyS[yypt-0].item.(*ast.PartitionDefinition)}
		}
	case 244:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.PartitionDefinition), yyS[yypt-0].item.(*ast.PartitionDefinition))
		}
	case 245:
		{
			parser.yyVAL.item = &ast.PartitionDefinition{
				Name:    model.NewCIStr(yyS[yypt-3].ident),
				Clause:  yyS[yypt-2].item.(ast.PartitionDefinitionClause),
				Options: yyS[yypt-1].item.([]*ast.TableOption),
				Sub:     yyS[yypt-0].item.([]*ast.SubPartitionDefinition),
			}
		}
	case 246:
		{
			parser.yyVAL.item = make([]*ast.SubPartitionDefinition, 0)
		}
	case 247:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 248:
		{
			parser.yyVAL.item = []*ast.SubPartitionDefinition{yyS[yypt-0].item.(*ast.SubPartitionDefinition)}
		}
	case 249:
		{
			list := yyS[yypt-2].item.([]*ast.SubPartitionDefinition)
			parser.yyVAL.item = append(list, yyS[yypt-0].item.(*ast.SubPartitionDefinition))
		}
	case 250:
		{
			parser.yyVAL.item = &ast.SubPartitionDefinition{
				Name:    model.NewCIStr(yyS[yypt-1].ident),
				Options: yyS[yypt-0].item.([]*ast.TableOption),
			}
		}
	case 251:
		{
			parser.yyVAL.item = make([]*ast.TableOption, 0)
		}
	case 252:
		{
			list := yyS[yypt-1].item.([]*ast.TableOption)
			parser.yyVAL.item = append(list, yyS[yypt-0].item.(*ast.TableOption))
		}
	case 253:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionComment, StrValue: yyS[yypt-0].ident}
		}
	case 254:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionEngine, StrValue: yyS[yypt-0].item.(string)}
		}
	case 255:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionInsertMethod, StrValue: yyS[yypt-0].item.(string)}
		}
	case 256:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionDataDirectory, StrValue: yyS[yypt-0].ident}
		}
	case 257:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionIndexDirectory, StrValue: yyS[yypt-0].ident}
		}
	case 258:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionMaxRows, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 259:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionMinRows, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 260:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionTablespace, StrValue: yyS[yypt-0].ident}
		}
	case 261:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionNodegroup, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 262:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseNone{}
		}
	case 263:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseLessThan{
				Exprs: []ast.ExprNode{&ast.MaxValueExpr{}},
			}
		}
	case 264:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseLessThan{
				Exprs: yyS[yypt-1].item.([]ast.ExprNode),
			}
		}
	case 265:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseIn{}
		}
	case 266:
		{
			exprs := yyS[yypt-1].item.([]ast.ExprNode)
			values := make([][]ast.ExprNode, 0, len(exprs))
			for _, expr := range exprs {
				if row, ok := expr.(*ast.RowExpr); ok {
					values = append(values, row.Values)
				} else {
					values = append(values, []ast.ExprNode{expr})
				}
			}
			parser.yyVAL.item = &ast.PartitionDefinitionClauseIn{Values: values}
		}
	case 267:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseHistory{Current: false}
		}
	case 268:
		{
			parser.yyVAL.item = &ast.PartitionDefinitionClauseHistory{Current: true}
		}
	case 269:
		{
			parser.yyVAL.item = ast.OnDuplicateKeyHandlingError
		}
	case 270:
		{
			parser.yyVAL.item = ast.OnDuplicateKeyHandlingIgnore
		}
	case 271:
		{
			parser.yyVAL.item = ast.OnDuplicateKeyHandlingReplace
		}
	case 274:
		{
			parser.yyVAL.item = &ast.CreateTableStmt{}
		}
	case 275:
		{
			parser.yyVAL.item = &ast.CreateTableStmt{Select: yyS[yypt-0].statement}
		}
	case 276:
		{
			parser.yyVAL.item = &ast.CreateTableStmt{Select: yyS[yypt-0].statement}
		}
	case 277:
		{
			parser.yyVAL.item = &ast.CreateTableStmt{Select: yyS[yypt-0].expr}
		}
	case 278:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 279:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 280:
		{
			startOffset := parser.startOffset(&yyS[yypt-1])
			selStmt := yyS[yypt-1].statement.(*ast.SelectStmt)
			selStmt.SetText(strings.TrimSpace(parser.src[startOffset:]))
			x := &ast.CreateViewStmt{
				OrReplace: yyS[yypt-9].item.(bool),
				ViewName:  yyS[yypt-4].item.(*ast.TableName),
				Select:    selStmt,
				Algorithm: yyS[yypt-8].item.(model.ViewAlgorithm),
				Definer:   yyS[yypt-7].item.(*auth.UserIdentity),
				Security:  yyS[yypt-6].item.(model.ViewSecurity),
			}
			if yyS[yypt-3].item != nil {
				x.Cols = yyS[yypt-3].item.([]model.CIStr)
			}
			if yyS[yypt-0].item != nil {
				x.CheckOption = yyS[yypt-0].item.(model.ViewCheckOption)
				endOffset := parser.startOffset(&yyS[yypt])
				selStmt.SetText(strings.TrimSpace(parser.src[startOffset:endOffset]))
			} else {
				x.CheckOption = model.CheckOptionCascaded
			}
			parser.yyVAL.statement = x
		}
	case 281:
		{
			parser.yyVAL.item = false
		}
	case 282:
		{
			parser.yyVAL.item = true
		}
	case 283:
		{
			parser.yyVAL.item = model.AlgorithmUndefined
		}
	case 284:
		{
			parser.yyVAL.item = model.AlgorithmUndefined
		}
	case 285:
		{
			parser.yyVAL.item = model.AlgorithmMerge
		}
	case 286:
		{
			parser.yyVAL.item = model.AlgorithmTemptable
		}
	case 287:
		{
			parser.yyVAL.item = &auth.UserIdentity{CurrentUser: true}
		}
	case 288:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 289:
		{
			parser.yyVAL.item = model.SecurityDefiner
		}
	case 290:
		{
			parser.yyVAL.item = model.SecurityDefiner
		}
	case 291:
		{
			parser.yyVAL.item = model.SecurityInvoker
		}
	case 292:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(*ast.TableName)
		}
	case 293:
		{
			parser.yyVAL.item = nil
		}
	case 294:
		{
			parser.yyVAL.item = yyS[yypt-1].item.([]model.CIStr)
		}
	case 295:
		{
			parser.yyVAL.item = []model.CIStr{model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 296:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]model.CIStr), model.NewCIStr(yyS[yypt-0].ident))
		}
	case 297:
		{
			parser.yyVAL.item = nil
		}
	case 298:
		{
			parser.yyVAL.item = model.CheckOptionCascaded
		}
	case 299:
		{
			parser.yyVAL.item = model.CheckOptionLocal
		}
	case 300:
		{
			parser.yyVAL.statement = &ast.DoStmt{
				Exprs: yyS[yypt-0].item.([]ast.ExprNode),
			}
		}
	case 301:
		{
			// Single Table
			tn := yyS[yypt-5].item.(*ast.TableName)
			tn.IndexHints = yyS[yypt-3].item.([]*ast.IndexHint)
			join := &ast.Join{Left: &ast.TableSource{Source: tn, AsName: yyS[yypt-4].item.(model.CIStr)}, Right: nil}
			x := &ast.DeleteStmt{
				TableRefs: &ast.TableRefsClause{TableRefs: join},
				Priority:  yyS[yypt-9].item.(mysql.PriorityEnum),
				Quick:     yyS[yypt-8].item.(bool),
				IgnoreErr: yyS[yypt-7].item.(bool),
			}
			if yyS[yypt-2].item != nil {
				x.Where = yyS[yypt-2].item.(ast.ExprNode)
			}
			if yyS[yypt-1].item != nil {
				x.Order = yyS[yypt-1].item.(*ast.OrderByClause)
			}
			if yyS[yypt-0].item != nil {
				x.Limit = yyS[yypt-0].item.(*ast.Limit)
			}

			parser.yyVAL.statement = x
		}
	case 302:
		{
			// Multiple Table
			x := &ast.DeleteStmt{
				Priority:     yyS[yypt-6].item.(mysql.PriorityEnum),
				Quick:        yyS[yypt-5].item.(bool),
				IgnoreErr:    yyS[yypt-4].item.(bool),
				IsMultiTable: true,
				BeforeFrom:   true,
				Tables:       &ast.DeleteTableList{Tables: yyS[yypt-3].item.([]*ast.TableName)},
				TableRefs:    &ast.TableRefsClause{TableRefs: yyS[yypt-1].item.(*ast.Join)},
			}
			if yyS[yypt-7].item != nil {
				x.TableHints = yyS[yypt-7].item.([]*ast.TableOptimizerHint)
			}
			if yyS[yypt-0].item != nil {
				x.Where = yyS[yypt-0].item.(ast.ExprNode)
			}
			parser.yyVAL.statement = x
		}
	case 303:
		{
			// Multiple Table
			x := &ast.DeleteStmt{
				Priority:     yyS[yypt-7].item.(mysql.PriorityEnum),
				Quick:        yyS[yypt-6].item.(bool),
				IgnoreErr:    yyS[yypt-5].item.(bool),
				IsMultiTable: true,
				Tables:       &ast.DeleteTableList{Tables: yyS[yypt-3].item.([]*ast.TableName)},
				TableRefs:    &ast.TableRefsClause{TableRefs: yyS[yypt-1].item.(*ast.Join)},
			}
			if yyS[yypt-8].item != nil {
				x.TableHints = yyS[yypt-8].item.([]*ast.TableOptimizerHint)
			}
			if yyS[yypt-0].item != nil {
				x.Where = yyS[yypt-0].item.(ast.ExprNode)
			}
			parser.yyVAL.statement = x
		}
	case 305:
		{
			parser.yyVAL.statement = &ast.DropDatabaseStmt{IfExists: yyS[yypt-1].item.(bool), Name: yyS[yypt-0].item.(string)}
		}
	case 306:
		{
			parser.yyVAL.statement = &ast.DropIndexStmt{IfExists: yyS[yypt-3].item.(bool), IndexName: yyS[yypt-2].ident, Table: yyS[yypt-0].item.(*ast.TableName)}
		}
	case 307:
		{
			parser.yyVAL.statement = &ast.DropTableStmt{IfExists: yyS[yypt-2].item.(bool), Tables: yyS[yypt-1].item.([]*ast.TableName), IsView: false, IsTemporary: yyS[yypt-4].item.(bool)}
		}
	case 308:
		{
			parser.yyVAL.item = false
		}
	case 309:
		{
			parser.yyVAL.item = true
			yylex.AppendError(yylex.Errorf("TiDB doesn't support TEMPORARY TABLE, TEMPORARY will be parsed but ignored."))
			parser.lastErrorAsWarn()
		}
	case 310:
		{
			parser.yyVAL.statement = &ast.DropTableStmt{Tables: yyS[yypt-1].item.([]*ast.TableName), IsView: true}
		}
	case 311:
		{
			parser.yyVAL.statement = &ast.DropTableStmt{IfExists: true, Tables: yyS[yypt-1].item.([]*ast.TableName), IsView: true}
		}
	case 312:
		{
			parser.yyVAL.statement = &ast.DropUserStmt{IsDropRole: false, IfExists: false, UserList: yyS[yypt-0].item.([]*auth.UserIdentity)}
		}
	case 313:
		{
			parser.yyVAL.statement = &ast.DropUserStmt{IsDropRole: false, IfExists: true, UserList: yyS[yypt-0].item.([]*auth.UserIdentity)}
		}
	case 314:
		{
			tmp := make([]*auth.UserIdentity, 0, 10)
			roleList := yyS[yypt-0].item.([]*auth.RoleIdentity)
			for _, r := range roleList {
				tmp = append(tmp, &auth.UserIdentity{Username: r.Username, Hostname: r.Hostname})
			}
			parser.yyVAL.statement = &ast.DropUserStmt{IsDropRole: true, IfExists: false, UserList: tmp}
		}
	case 315:
		{
			tmp := make([]*auth.UserIdentity, 0, 10)
			roleList := yyS[yypt-0].item.([]*auth.RoleIdentity)
			for _, r := range roleList {
				tmp = append(tmp, &auth.UserIdentity{Username: r.Username, Hostname: r.Hostname})
			}
			parser.yyVAL.statement = &ast.DropUserStmt{IsDropRole: true, IfExists: true, UserList: tmp}
		}
	case 316:
		{
			parser.yyVAL.statement = &ast.DropStatsStmt{Table: yyS[yypt-0].item.(*ast.TableName)}
		}
	case 324:
		{
			parser.yyVAL.statement = nil
		}
	case 325:
		{
			parser.yyVAL.statement = &ast.TraceStmt{
				Stmt:   yyS[yypt-0].statement,
				Format: "json",
			}
			startOffset := parser.startOffset(&yyS[yypt])
			yyS[yypt-0].statement.SetText(string(parser.src[startOffset:]))
		}
	case 326:
		{
			parser.yyVAL.statement = &ast.TraceStmt{
				Stmt:   yyS[yypt-0].statement,
				Format: yyS[yypt-1].ident,
			}
			startOffset := parser.startOffset(&yyS[yypt])
			yyS[yypt-0].statement.SetText(string(parser.src[startOffset:]))
		}
	case 330:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt: &ast.ShowStmt{
					Tp:    ast.ShowColumns,
					Table: yyS[yypt-0].item.(*ast.TableName),
				},
			}
		}
	case 331:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt: &ast.ShowStmt{
					Tp:     ast.ShowColumns,
					Table:  yyS[yypt-1].item.(*ast.TableName),
					Column: yyS[yypt-0].item.(*ast.ColumnName),
				},
			}
		}
	case 332:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt:   yyS[yypt-0].statement,
				Format: "row",
			}
		}
	case 333:
		{
			parser.yyVAL.statement = &ast.ExplainForStmt{
				Format:       "row",
				ConnectionID: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 334:
		{
			parser.yyVAL.statement = &ast.ExplainForStmt{
				Format:       yyS[yypt-3].ident,
				ConnectionID: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 335:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt:   yyS[yypt-0].statement,
				Format: yyS[yypt-1].ident,
			}
		}
	case 336:
		{
			parser.yyVAL.statement = &ast.ExplainForStmt{
				Format:       yyS[yypt-3].item.(string),
				ConnectionID: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 337:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt:   yyS[yypt-0].statement,
				Format: yyS[yypt-1].item.(string),
			}
		}
	case 338:
		{
			parser.yyVAL.statement = &ast.ExplainStmt{
				Stmt:    yyS[yypt-0].statement,
				Format:  "row",
				Analyze: true,
			}
		}
	case 339:
		{
			parser.yyVAL.item = "row"
		}
	case 340:
		{
			parser.yyVAL.item = "json"
		}
	case 341:
		{
			parser.yyVAL.item = getUint64FromNUM(yyS[yypt-0].item)
		}
	case 343:
		{
			v := yyS[yypt-2].ident
			v = strings.TrimPrefix(v, "@")
			parser.yyVAL.expr = &ast.VariableExpr{
				Name:     v,
				IsGlobal: false,
				IsSystem: false,
				Value:    yyS[yypt-0].expr,
			}
		}
	case 344:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.LogicOr, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 345:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.LogicXor, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 346:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.LogicAnd, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 347:
		{
			expr, ok := yyS[yypt-0].expr.(*ast.ExistsSubqueryExpr)
			if ok {
				expr.Not = true
				parser.yyVAL.expr = yyS[yypt-0].expr
			} else {
				parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Not, V: yyS[yypt-0].expr}
			}
		}
	case 348:
		{
			parser.yyVAL.expr = &ast.IsTruthExpr{Expr: yyS[yypt-2].expr, Not: !yyS[yypt-1].item.(bool), True: int64(1)}
		}
	case 349:
		{
			parser.yyVAL.expr = &ast.IsTruthExpr{Expr: yyS[yypt-2].expr, Not: !yyS[yypt-1].item.(bool), True: int64(0)}
		}
	case 350:
		{
			/* https://dev.mysql.com/doc/refman/5.7/en/comparison-operators.html#operator_is */
			parser.yyVAL.expr = &ast.IsNullExpr{Expr: yyS[yypt-2].expr, Not: !yyS[yypt-1].item.(bool)}
		}
	case 352:
		{
			parser.yyVAL.expr = &ast.MaxValueExpr{}
		}
	case 353:
		{
			parser.yyVAL.expr = yyS[yypt-0].expr
		}
	case 358:
		{
			parser.yyVAL.item = []ast.ExprNode{yyS[yypt-0].expr}
		}
	case 359:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.ExprNode), yyS[yypt-0].expr)
		}
	case 360:
		{
			parser.yyVAL.item = []ast.ExprNode{yyS[yypt-0].expr}
		}
	case 361:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.ExprNode), yyS[yypt-0].expr)
		}
	case 362:
		{
			parser.yyVAL.item = []ast.ExprNode{}
		}
	case 364:
		{
			parser.yyVAL.item = []ast.ExprNode{}
		}
	case 365:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 366:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].item)
			parser.yyVAL.item = []ast.ExprNode{expr}
		}
	case 367:
		{
			parser.yyVAL.expr = &ast.IsNullExpr{Expr: yyS[yypt-2].expr, Not: !yyS[yypt-1].item.(bool)}
		}
	case 368:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: yyS[yypt-1].item.(opcode.Op), L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 369:
		{
			sq := yyS[yypt-0].expr.(*ast.SubqueryExpr)
			sq.MultiRows = true
			parser.yyVAL.expr = &ast.CompareSubqueryExpr{Op: yyS[yypt-2].item.(opcode.Op), L: yyS[yypt-3].expr, R: sq, All: yyS[yypt-1].item.(bool)}
		}
	case 370:
		{
			v := yyS[yypt-2].ident
			v = strings.TrimPrefix(v, "@")
			variable := &ast.VariableExpr{
				Name:     v,
				IsGlobal: false,
				IsSystem: false,
				Value:    yyS[yypt-0].expr,
			}
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: yyS[yypt-3].item.(opcode.Op), L: yyS[yypt-4].expr, R: variable}
		}
	case 372:
		{
			parser.yyVAL.item = opcode.GE
		}
	case 373:
		{
			parser.yyVAL.item = opcode.GT
		}
	case 374:
		{
			parser.yyVAL.item = opcode.LE
		}
	case 375:
		{
			parser.yyVAL.item = opcode.LT
		}
	case 376:
		{
			parser.yyVAL.item = opcode.NE
		}
	case 377:
		{
			parser.yyVAL.item = opcode.NE
		}
	case 378:
		{
			parser.yyVAL.item = opcode.EQ
		}
	case 379:
		{
			parser.yyVAL.item = opcode.NullEQ
		}
	case 380:
		{
			parser.yyVAL.item = true
		}
	case 381:
		{
			parser.yyVAL.item = false
		}
	case 382:
		{
			parser.yyVAL.item = true
		}
	case 383:
		{
			parser.yyVAL.item = false
		}
	case 384:
		{
			parser.yyVAL.item = true
		}
	case 385:
		{
			parser.yyVAL.item = false
		}
	case 386:
		{
			parser.yyVAL.item = true
		}
	case 387:
		{
			parser.yyVAL.item = false
		}
	case 388:
		{
			parser.yyVAL.item = true
		}
	case 389:
		{
			parser.yyVAL.item = false
		}
	case 390:
		{
			parser.yyVAL.item = false
		}
	case 391:
		{
			parser.yyVAL.item = false
		}
	case 392:
		{
			parser.yyVAL.item = true
		}
	case 393:
		{
			parser.yyVAL.expr = &ast.PatternInExpr{Expr: yyS[yypt-4].expr, Not: !yyS[yypt-3].item.(bool), List: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 394:
		{
			sq := yyS[yypt-0].expr.(*ast.SubqueryExpr)
			sq.MultiRows = true
			parser.yyVAL.expr = &ast.PatternInExpr{Expr: yyS[yypt-2].expr, Not: !yyS[yypt-1].item.(bool), Sel: sq}
		}
	case 395:
		{
			parser.yyVAL.expr = &ast.BetweenExpr{
				Expr:  yyS[yypt-4].expr,
				Left:  yyS[yypt-2].expr,
				Right: yyS[yypt-0].expr,
				Not:   !yyS[yypt-3].item.(bool),
			}
		}
	case 396:
		{
			escape := yyS[yypt-0].item.(string)
			if len(escape) > 1 {
				yylex.AppendError(ErrWrongArguments.GenWithStackByArgs("ESCAPE"))
				return 1
			} else if len(escape) == 0 {
				escape = "\\"
			}
			parser.yyVAL.expr = &ast.PatternLikeExpr{
				Expr:    yyS[yypt-3].expr,
				Pattern: yyS[yypt-1].expr,
				Not:     !yyS[yypt-2].item.(bool),
				Escape:  escape[0],
			}
		}
	case 397:
		{
			parser.yyVAL.expr = &ast.PatternRegexpExpr{Expr: yyS[yypt-2].expr, Pattern: yyS[yypt-0].expr, Not: !yyS[yypt-1].item.(bool)}
		}
	case 401:
		{
			parser.yyVAL.item = "\\"
		}
	case 402:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 403:
		{
			parser.yyVAL.item = &ast.SelectField{WildCard: &ast.WildCardField{}}
		}
	case 404:
		{
			wildCard := &ast.WildCardField{Table: model.NewCIStr(yyS[yypt-2].ident)}
			parser.yyVAL.item = &ast.SelectField{WildCard: wildCard}
		}
	case 405:
		{
			wildCard := &ast.WildCardField{Schema: model.NewCIStr(yyS[yypt-4].ident), Table: model.NewCIStr(yyS[yypt-2].ident)}
			parser.yyVAL.item = &ast.SelectField{WildCard: wildCard}
		}
	case 406:
		{
			expr := yyS[yypt-1].expr
			asName := yyS[yypt-0].item.(string)
			parser.yyVAL.item = &ast.SelectField{Expr: expr, AsName: model.NewCIStr(asName)}
		}
	case 407:
		{
			/*
			* ODBC escape syntax.
			* See https://dev.mysql.com/doc/refman/5.7/en/expressions.html
			 */
			expr := yyS[yypt-2].expr
			asName := yyS[yypt-0].item.(string)
			parser.yyVAL.item = &ast.SelectField{Expr: expr, AsName: model.NewCIStr(asName)}
		}
	case 408:
		{
			parser.yyVAL.item = ""
		}
	case 409:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 410:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 411:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 412:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 413:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 414:
		{
			field := yyS[yypt-0].item.(*ast.SelectField)
			field.Offset = parser.startOffset(&yyS[yypt])
			parser.yyVAL.item = []*ast.SelectField{field}
		}
	case 415:
		{

			fl := yyS[yypt-2].item.([]*ast.SelectField)
			last := fl[len(fl)-1]
			if last.Expr != nil && last.AsName.O == "" {
				lastEnd := parser.endOffset(&yyS[yypt-1])
				last.SetText(parser.src[last.Offset:lastEnd])
			}
			newField := yyS[yypt-0].item.(*ast.SelectField)
			newField.Offset = parser.startOffset(&yyS[yypt])
			parser.yyVAL.item = append(fl, newField)
		}
	case 416:
		{
			parser.yyVAL.item = &ast.GroupByClause{Items: yyS[yypt-0].item.([]*ast.ByItem)}
		}
	case 417:
		{
			parser.yyVAL.item = nil
		}
	case 418:
		{
			parser.yyVAL.item = &ast.HavingClause{Expr: yyS[yypt-0].expr}
		}
	case 419:
		{
			parser.yyVAL.item = false
		}
	case 420:
		{
			parser.yyVAL.item = true
		}
	case 421:
		{
			parser.yyVAL.item = false
		}
	case 422:
		{
			parser.yyVAL.item = true
		}
	case 423:
		{
			parser.yyVAL.item = false
		}
	case 424:
		{
			parser.yyVAL.item = true
		}
	case 425:
		{
			parser.yyVAL.item = ""
		}
	case 426:
		{
			//"index name"
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 427:
		{
			parser.yyVAL.item = nil
		}
	case 428:
		{
			// Merge the options
			if yyS[yypt-1].item == nil {
				parser.yyVAL.item = yyS[yypt-0].item
			} else {
				opt1 := yyS[yypt-1].item.(*ast.IndexOption)
				opt2 := yyS[yypt-0].item.(*ast.IndexOption)
				if len(opt2.Comment) > 0 {
					opt1.Comment = opt2.Comment
				} else if opt2.Tp != 0 {
					opt1.Tp = opt2.Tp
				} else if opt2.KeyBlockSize > 0 {
					opt1.KeyBlockSize = opt2.KeyBlockSize
				}
				parser.yyVAL.item = opt1
			}
		}
	case 429:
		{
			parser.yyVAL.item = &ast.IndexOption{
				KeyBlockSize: yyS[yypt-0].item.(uint64),
			}
		}
	case 430:
		{
			parser.yyVAL.item = &ast.IndexOption{
				Tp: yyS[yypt-0].item.(model.IndexType),
			}
		}
	case 431:
		{
			parser.yyVAL.item = &ast.IndexOption{
				Comment: yyS[yypt-0].ident,
			}
		}
	case 432:
		{
			parser.yyVAL.item = model.IndexTypeBtree
		}
	case 433:
		{
			parser.yyVAL.item = model.IndexTypeHash
		}
	case 434:
		{
			parser.yyVAL.item = model.IndexTypeRtree
		}
	case 435:
		{
			parser.yyVAL.item = nil
		}
	case 436:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 728:
		{
			x := yyS[yypt-1].item.(*ast.InsertStmt)
			x.Priority = yyS[yypt-5].item.(mysql.PriorityEnum)
			x.IgnoreErr = yyS[yypt-4].item.(bool)
			// Wraps many layers here so that it can be processed the same way as select statement.
			ts := &ast.TableSource{Source: yyS[yypt-2].item.(*ast.TableName)}
			x.Table = &ast.TableRefsClause{TableRefs: &ast.Join{Left: ts}}
			if yyS[yypt-0].item != nil {
				x.OnDuplicate = yyS[yypt-0].item.([]*ast.Assignment)
			}
			parser.yyVAL.statement = x
		}
	case 731:
		{
			parser.yyVAL.item = &ast.InsertStmt{
				Columns: yyS[yypt-3].item.([]*ast.ColumnName),
				Lists:   yyS[yypt-0].item.([][]ast.ExprNode),
			}
		}
	case 732:
		{
			parser.yyVAL.item = &ast.InsertStmt{Columns: yyS[yypt-2].item.([]*ast.ColumnName), Select: yyS[yypt-0].statement.(*ast.SelectStmt)}
		}
	case 733:
		{
			parser.yyVAL.item = &ast.InsertStmt{Columns: yyS[yypt-4].item.([]*ast.ColumnName), Select: yyS[yypt-1].statement.(*ast.SelectStmt)}
		}
	case 734:
		{
			parser.yyVAL.item = &ast.InsertStmt{Columns: yyS[yypt-2].item.([]*ast.ColumnName), Select: yyS[yypt-0].statement.(*ast.UnionStmt)}
		}
	case 735:
		{
			parser.yyVAL.item = &ast.InsertStmt{Lists: yyS[yypt-0].item.([][]ast.ExprNode)}
		}
	case 736:
		{
			parser.yyVAL.item = &ast.InsertStmt{Select: yyS[yypt-1].statement.(*ast.SelectStmt)}
		}
	case 737:
		{
			parser.yyVAL.item = &ast.InsertStmt{Select: yyS[yypt-0].statement.(*ast.SelectStmt)}
		}
	case 738:
		{
			parser.yyVAL.item = &ast.InsertStmt{Select: yyS[yypt-0].statement.(*ast.UnionStmt)}
		}
	case 739:
		{
			parser.yyVAL.item = &ast.InsertStmt{Setlist: yyS[yypt-0].item.([]*ast.Assignment)}
		}
	case 742:
		{
			parser.yyVAL.item = [][]ast.ExprNode{yyS[yypt-0].item.([]ast.ExprNode)}
		}
	case 743:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([][]ast.ExprNode), yyS[yypt-0].item.([]ast.ExprNode))
		}
	case 744:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 745:
		{
			parser.yyVAL.item = []ast.ExprNode{}
		}
	case 747:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.ExprNode), yyS[yypt-0].expr)
		}
	case 748:
		{
			parser.yyVAL.item = []ast.ExprNode{yyS[yypt-0].expr}
		}
	case 750:
		{
			parser.yyVAL.expr = &ast.DefaultExpr{}
		}
	case 751:
		{
			parser.yyVAL.item = &ast.Assignment{
				Column: yyS[yypt-2].item.(*ast.ColumnName),
				Expr:   yyS[yypt-0].expr,
			}
		}
	case 752:
		{
			parser.yyVAL.item = []*ast.Assignment{}
		}
	case 753:
		{
			parser.yyVAL.item = []*ast.Assignment{yyS[yypt-0].item.(*ast.Assignment)}
		}
	case 754:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.Assignment), yyS[yypt-0].item.(*ast.Assignment))
		}
	case 755:
		{
			parser.yyVAL.item = nil
		}
	case 756:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 757:
		{
			x := yyS[yypt-0].item.(*ast.InsertStmt)
			x.IsReplace = true
			x.Priority = yyS[yypt-3].item.(mysql.PriorityEnum)
			ts := &ast.TableSource{Source: yyS[yypt-1].item.(*ast.TableName)}
			x.Table = &ast.TableRefsClause{TableRefs: &ast.Join{Left: ts}}
			parser.yyVAL.statement = x
		}
	case 758:
		{
			parser.yyVAL.ident = ast.DateLiteral
		}
	case 759:
		{
			parser.yyVAL.ident = ast.TimeLiteral
		}
	case 760:
		{
			parser.yyVAL.ident = ast.TimestampLiteral
		}
	case 761:
		{
			parser.yyVAL.expr = ast.NewValueExpr(false)
		}
	case 762:
		{
			parser.yyVAL.expr = ast.NewValueExpr(nil)
		}
	case 763:
		{
			parser.yyVAL.expr = ast.NewValueExpr(true)
		}
	case 764:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 765:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 766:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 767:
		{
			parser.yyVAL.expr = yyS[yypt-0].expr
		}
	case 768:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/charset-literal.html
			co, err := charset.GetDefaultCollation(yyS[yypt-1].ident)
			if err != nil {
				yylex.AppendError(yylex.Errorf("Get collation error for charset: %s", yyS[yypt-1].ident))
				return 1
			}
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			tp := expr.GetType()
			tp.Charset = yyS[yypt-1].ident
			tp.Collate = co
			if tp.Collate == charset.CollationBin {
				tp.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.expr = expr
		}
	case 769:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 770:
		{
			parser.yyVAL.expr = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 771:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			parser.yyVAL.expr = expr
		}
	case 772:
		{
			valExpr := yyS[yypt-1].expr.(ast.ValueExpr)
			strLit := valExpr.GetString()
			expr := ast.NewValueExpr(strLit + yyS[yypt-0].ident)
			// Fix #4239, use first string literal as projection name.
			if valExpr.GetProjectionOffset() >= 0 {
				expr.SetProjectionOffset(valExpr.GetProjectionOffset())
			} else {
				expr.SetProjectionOffset(len(strLit))
			}
			parser.yyVAL.expr = expr
		}
	case 773:
		{
			parser.yyVAL.item = &ast.OrderByClause{Items: yyS[yypt-0].item.([]*ast.ByItem)}
		}
	case 774:
		{
			parser.yyVAL.item = []*ast.ByItem{yyS[yypt-0].item.(*ast.ByItem)}
		}
	case 775:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.ByItem), yyS[yypt-0].item.(*ast.ByItem))
		}
	case 776:
		{
			expr := yyS[yypt-1].expr
			valueExpr, ok := expr.(ast.ValueExpr)
			if ok {
				position, isPosition := valueExpr.GetValue().(int64)
				if isPosition {
					expr = &ast.PositionExpr{N: int(position)}
				}
			}
			parser.yyVAL.item = &ast.ByItem{Expr: expr, Desc: yyS[yypt-0].item.(bool)}
		}
	case 777:
		{
			parser.yyVAL.item = false // ASC by default
		}
	case 778:
		{
			parser.yyVAL.item = false
		}
	case 779:
		{
			parser.yyVAL.item = true
		}
	case 780:
		{
			parser.yyVAL.item = nil
		}
	case 781:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 782:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Or, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 783:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.And, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 784:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.LeftShift, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 785:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.RightShift, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 786:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Plus, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 787:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Minus, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 788:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr("DATE_ADD"),
				Args: []ast.ExprNode{
					yyS[yypt-4].expr,
					yyS[yypt-1].expr,
					&ast.TimeUnitExpr{Unit: yyS[yypt-0].item.(ast.TimeUnitType)},
				},
			}
		}
	case 789:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr("DATE_SUB"),
				Args: []ast.ExprNode{
					yyS[yypt-4].expr,
					yyS[yypt-1].expr,
					&ast.TimeUnitExpr{Unit: yyS[yypt-0].item.(ast.TimeUnitType)},
				},
			}
		}
	case 790:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Mul, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 791:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Div, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 792:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Mod, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 793:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.IntDiv, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 794:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Mod, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 795:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Xor, L: yyS[yypt-2].expr, R: yyS[yypt-0].expr}
		}
	case 797:
		{
			parser.yyVAL.expr = &ast.ColumnNameExpr{Name: &ast.ColumnName{
				Name: model.NewCIStr(yyS[yypt-0].ident),
			}}
		}
	case 798:
		{
			parser.yyVAL.expr = &ast.ColumnNameExpr{Name: &ast.ColumnName{
				Table: model.NewCIStr(yyS[yypt-2].ident),
				Name:  model.NewCIStr(yyS[yypt-0].ident),
			}}
		}
	case 799:
		{
			parser.yyVAL.expr = &ast.ColumnNameExpr{Name: &ast.ColumnName{
				Table: model.NewCIStr(yyS[yypt-2].ident),
				Name:  model.NewCIStr(yyS[yypt-0].ident),
			}}
		}
	case 800:
		{
			parser.yyVAL.expr = &ast.ColumnNameExpr{Name: &ast.ColumnName{
				Schema: model.NewCIStr(yyS[yypt-4].ident),
				Table:  model.NewCIStr(yyS[yypt-2].ident),
				Name:   model.NewCIStr(yyS[yypt-0].ident),
			}}
		}
	case 805:
		{
			// TODO: Create a builtin function hold expr and collation. When do evaluation, convert expr result using the collation.
			parser.yyVAL.expr = yyS[yypt-2].expr
		}
	case 806:
		{
			parser.yyVAL.expr = yyS[yypt-0].item.(*ast.WindowFuncExpr)
		}
	case 808:
		{
			parser.yyVAL.expr = ast.NewParamMarkerExpr(yyS[yypt].offset)
		}
	case 811:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Not, V: yyS[yypt-0].expr}
		}
	case 812:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.BitNeg, V: yyS[yypt-0].expr}
		}
	case 813:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Minus, V: yyS[yypt-0].expr}
		}
	case 814:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Plus, V: yyS[yypt-0].expr}
		}
	case 815:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.Concat), Args: []ast.ExprNode{yyS[yypt-2].expr, yyS[yypt-0].expr}}
		}
	case 816:
		{
			parser.yyVAL.expr = &ast.UnaryOperationExpr{Op: opcode.Not, V: yyS[yypt-0].expr}
		}
	case 818:
		{
			startOffset := parser.startOffset(&yyS[yypt-1])
			endOffset := parser.endOffset(&yyS[yypt])
			expr := yyS[yypt-1].expr
			expr.SetText(parser.src[startOffset:endOffset])
			parser.yyVAL.expr = &ast.ParenthesesExpr{Expr: expr}
		}
	case 819:
		{
			values := append(yyS[yypt-3].item.([]ast.ExprNode), yyS[yypt-1].expr)
			parser.yyVAL.expr = &ast.RowExpr{Values: values}
		}
	case 820:
		{
			values := append(yyS[yypt-3].item.([]ast.ExprNode), yyS[yypt-1].expr)
			parser.yyVAL.expr = &ast.RowExpr{Values: values}
		}
	case 821:
		{
			sq := yyS[yypt-0].expr.(*ast.SubqueryExpr)
			sq.Exists = true
			parser.yyVAL.expr = &ast.ExistsSubqueryExpr{Sel: sq}
		}
	case 822:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html#operator_binary
			x := types.NewFieldType(mysql.TypeString)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CharsetBin
			parser.yyVAL.expr = &ast.FuncCastExpr{
				Expr:         yyS[yypt-0].expr,
				Tp:           x,
				FunctionType: ast.CastBinaryOperator,
			}
		}
	case 823:
		{
			/* See https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html#function_cast */
			tp := yyS[yypt-1].item.(*types.FieldType)
			defaultFlen, defaultDecimal := mysql.GetDefaultFieldLengthAndDecimalForCast(tp.Tp)
			if tp.Flen == types.UnspecifiedLength {
				tp.Flen = defaultFlen
			}
			if tp.Decimal == types.UnspecifiedLength {
				tp.Decimal = defaultDecimal
			}
			parser.yyVAL.expr = &ast.FuncCastExpr{
				Expr:         yyS[yypt-3].expr,
				Tp:           tp,
				FunctionType: ast.CastFunction,
			}
		}
	case 824:
		{
			x := &ast.CaseExpr{WhenClauses: yyS[yypt-2].item.([]*ast.WhenClause)}
			if yyS[yypt-3].expr != nil {
				x.Value = yyS[yypt-3].expr
			}
			if yyS[yypt-1].item != nil {
				x.ElseClause = yyS[yypt-1].item.(ast.ExprNode)
			}
			parser.yyVAL.expr = x
		}
	case 825:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html#function_convert
			tp := yyS[yypt-1].item.(*types.FieldType)
			defaultFlen, defaultDecimal := mysql.GetDefaultFieldLengthAndDecimalForCast(tp.Tp)
			if tp.Flen == types.UnspecifiedLength {
				tp.Flen = defaultFlen
			}
			if tp.Decimal == types.UnspecifiedLength {
				tp.Decimal = defaultDecimal
			}
			parser.yyVAL.expr = &ast.FuncCastExpr{
				Expr:         yyS[yypt-3].expr,
				Tp:           tp,
				FunctionType: ast.CastConvertFunction,
			}
		}
	case 826:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/cast-functions.html#function_convert
			charset1 := ast.NewValueExpr(yyS[yypt-1].item)
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{yyS[yypt-3].expr, charset1},
			}
		}
	case 827:
		{
			parser.yyVAL.expr = &ast.DefaultExpr{Name: yyS[yypt-1].expr.(*ast.ColumnNameExpr).Name}
		}
	case 828:
		{
			parser.yyVAL.expr = &ast.ValuesExpr{Column: yyS[yypt-1].expr.(*ast.ColumnNameExpr)}
		}
	case 829:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.JSONExtract), Args: []ast.ExprNode{yyS[yypt-2].expr, expr}}
		}
	case 830:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			extract := &ast.FuncCallExpr{FnName: model.NewCIStr(ast.JSONExtract), Args: []ast.ExprNode{yyS[yypt-2].expr, expr}}
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.JSONUnquote), Args: []ast.ExprNode{extract}}
		}
	case 833:
		{
			parser.yyVAL.item = false
		}
	case 834:
		{
			parser.yyVAL.item = true
		}
	case 835:
		{
			parser.yyVAL.item = false
		}
	case 837:
		{
			parser.yyVAL.item = true
		}
	case 840:
		{
			parser.yyVAL.item = true
		}
	case 882:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-3].ident), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 883:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-3].ident), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 884:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-1].ident)}
		}
	case 885:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-2].ident)}
		}
	case 886:
		{
			args := []ast.ExprNode{}
			if yyS[yypt-0].item != nil {
				args = append(args, yyS[yypt-0].item.(ast.ExprNode))
			}
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-1].ident), Args: args}
		}
	case 887:
		{
			nilVal := ast.NewValueExpr(nil)
			args := yyS[yypt-1].item.([]ast.ExprNode)
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(ast.CharFunc),
				Args:   append(args, nilVal),
			}
		}
	case 888:
		{
			charset1 := ast.NewValueExpr(yyS[yypt-1].item)
			args := yyS[yypt-3].item.([]ast.ExprNode)
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(ast.CharFunc),
				Args:   append(args, charset1),
			}
		}
	case 889:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.DateLiteral), Args: []ast.ExprNode{expr}}
		}
	case 890:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.TimeLiteral), Args: []ast.ExprNode{expr}}
		}
	case 891:
		{
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.TimestampLiteral), Args: []ast.ExprNode{expr}}
		}
	case 892:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.InsertFunc), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 893:
		{
			parser.yyVAL.expr = &ast.BinaryOperationExpr{Op: opcode.Mod, L: yyS[yypt-3].expr, R: yyS[yypt-1].expr}
		}
	case 894:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.PasswordFunc), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 895:
		{
			// This is ODBC syntax for date and time literals.
			// See: https://dev.mysql.com/doc/refman/5.7/en/date-and-time-literals.html
			expr := ast.NewValueExpr(yyS[yypt-1].ident)
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-2].ident), Args: []ast.ExprNode{expr}}
		}
	case 896:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-3].ident), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 897:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-3].ident), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 898:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args: []ast.ExprNode{
					yyS[yypt-3].expr,
					yyS[yypt-1].expr,
					&ast.TimeUnitExpr{Unit: ast.TimeUnitDay},
				},
			}
		}
	case 899:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args: []ast.ExprNode{
					yyS[yypt-5].expr,
					yyS[yypt-2].expr,
					&ast.TimeUnitExpr{Unit: yyS[yypt-1].item.(ast.TimeUnitType)},
				},
			}
		}
	case 900:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args: []ast.ExprNode{
					yyS[yypt-5].expr,
					yyS[yypt-2].expr,
					&ast.TimeUnitExpr{Unit: yyS[yypt-1].item.(ast.TimeUnitType)},
				},
			}
		}
	case 901:
		{
			timeUnit := &ast.TimeUnitExpr{Unit: yyS[yypt-3].item.(ast.TimeUnitType)}
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{timeUnit, yyS[yypt-1].expr},
			}
		}
	case 902:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args: []ast.ExprNode{
					&ast.GetFormatSelectorExpr{Selector: yyS[yypt-3].item.(ast.GetFormatSelectorType)},
					yyS[yypt-1].expr,
				},
			}
		}
	case 903:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-5].ident), Args: []ast.ExprNode{yyS[yypt-3].expr, yyS[yypt-1].expr}}
		}
	case 904:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 905:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 906:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args:   []ast.ExprNode{yyS[yypt-5].expr, yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 907:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args:   []ast.ExprNode{yyS[yypt-5].expr, yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 908:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args:   []ast.ExprNode{&ast.TimeUnitExpr{Unit: yyS[yypt-5].item.(ast.TimeUnitType)}, yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 909:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-7].ident),
				Args:   []ast.ExprNode{&ast.TimeUnitExpr{Unit: yyS[yypt-5].item.(ast.TimeUnitType)}, yyS[yypt-3].expr, yyS[yypt-1].expr},
			}
		}
	case 910:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-3].ident),
				Args:   []ast.ExprNode{yyS[yypt-1].expr},
			}
		}
	case 911:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{yyS[yypt-1].expr, yyS[yypt-3].expr},
			}
		}
	case 912:
		{
			nilVal := ast.NewValueExpr(nil)
			direction := &ast.TrimDirectionExpr{Direction: yyS[yypt-3].item.(ast.TrimDirectionType)}
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-5].ident),
				Args:   []ast.ExprNode{yyS[yypt-1].expr, nilVal, direction},
			}
		}
	case 913:
		{
			direction := &ast.TrimDirectionExpr{Direction: yyS[yypt-4].item.(ast.TrimDirectionType)}
			parser.yyVAL.expr = &ast.FuncCallExpr{
				FnName: model.NewCIStr(yyS[yypt-6].ident),
				Args:   []ast.ExprNode{yyS[yypt-1].expr, yyS[yypt-3].expr, direction},
			}
		}
	case 914:
		{
			parser.yyVAL.item = ast.GetFormatSelectorDate
		}
	case 915:
		{
			parser.yyVAL.item = ast.GetFormatSelectorDatetime
		}
	case 916:
		{
			parser.yyVAL.item = ast.GetFormatSelectorTime
		}
	case 917:
		{
			parser.yyVAL.item = ast.GetFormatSelectorDatetime
		}
	case 922:
		{
			parser.yyVAL.item = ast.TrimBoth
		}
	case 923:
		{
			parser.yyVAL.item = ast.TrimLeading
		}
	case 924:
		{
			parser.yyVAL.item = ast.TrimTrailing
		}
	case 925:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 926:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 927:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 928:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 929:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 930:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 931:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 932:
		{
			parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: yyS[yypt-1].item.([]ast.ExprNode), Distinct: true}
		}
	case 933:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 934:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}}
			}
		}
	case 935:
		{
			args := []ast.ExprNode{ast.NewValueExpr(1)}
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: args, Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-4].ident, Args: args}
			}
		}
	case 936:
		{
			args := yyS[yypt-3].item.([]ast.ExprNode)
			args = append(args, yyS[yypt-1].item.(ast.ExprNode))
			parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-6].ident, Args: args, Distinct: yyS[yypt-4].item.(bool)}
		}
	case 937:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 938:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 939:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 940:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 941:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.expr = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool), Spec: *(yyS[yypt-0].item.(*ast.WindowSpec))}
			} else {
				parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
			}
		}
	case 942:
		{
			parser.yyVAL.expr = &ast.AggregateFuncExpr{F: ast.AggFuncVarPop, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
		}
	case 943:
		{
			parser.yyVAL.expr = &ast.AggregateFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Distinct: yyS[yypt-3].item.(bool)}
		}
	case 944:
		{
			parser.yyVAL.item = ast.NewValueExpr(",")
		}
	case 945:
		{
			parser.yyVAL.item = ast.NewValueExpr(yyS[yypt-0].ident)
		}
	case 946:
		{
			parser.yyVAL.expr = &ast.FuncCallExpr{FnName: model.NewCIStr(yyS[yypt-3].ident), Args: yyS[yypt-1].item.([]ast.ExprNode)}
		}
	case 947:
		{
			parser.yyVAL.item = nil
		}
	case 948:
		{
			parser.yyVAL.item = nil
		}
	case 949:
		{
			expr := ast.NewValueExpr(yyS[yypt-1].item)
			parser.yyVAL.item = expr
		}
	case 950:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 951:
		{
			parser.yyVAL.item = ast.TimeUnitSecondMicrosecond
		}
	case 952:
		{
			parser.yyVAL.item = ast.TimeUnitMinuteMicrosecond
		}
	case 953:
		{
			parser.yyVAL.item = ast.TimeUnitMinuteSecond
		}
	case 954:
		{
			parser.yyVAL.item = ast.TimeUnitHourMicrosecond
		}
	case 955:
		{
			parser.yyVAL.item = ast.TimeUnitHourSecond
		}
	case 956:
		{
			parser.yyVAL.item = ast.TimeUnitHourMinute
		}
	case 957:
		{
			parser.yyVAL.item = ast.TimeUnitDayMicrosecond
		}
	case 958:
		{
			parser.yyVAL.item = ast.TimeUnitDaySecond
		}
	case 959:
		{
			parser.yyVAL.item = ast.TimeUnitDayMinute
		}
	case 960:
		{
			parser.yyVAL.item = ast.TimeUnitDayHour
		}
	case 961:
		{
			parser.yyVAL.item = ast.TimeUnitYearMonth
		}
	case 962:
		{
			parser.yyVAL.item = ast.TimeUnitMicrosecond
		}
	case 963:
		{
			parser.yyVAL.item = ast.TimeUnitSecond
		}
	case 964:
		{
			parser.yyVAL.item = ast.TimeUnitMinute
		}
	case 965:
		{
			parser.yyVAL.item = ast.TimeUnitHour
		}
	case 966:
		{
			parser.yyVAL.item = ast.TimeUnitDay
		}
	case 967:
		{
			parser.yyVAL.item = ast.TimeUnitWeek
		}
	case 968:
		{
			parser.yyVAL.item = ast.TimeUnitMonth
		}
	case 969:
		{
			parser.yyVAL.item = ast.TimeUnitQuarter
		}
	case 970:
		{
			parser.yyVAL.item = ast.TimeUnitYear
		}
	case 971:
		{
			parser.yyVAL.expr = nil
		}
	case 972:
		{
			parser.yyVAL.expr = yyS[yypt-0].expr
		}
	case 973:
		{
			parser.yyVAL.item = []*ast.WhenClause{yyS[yypt-0].item.(*ast.WhenClause)}
		}
	case 974:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.WhenClause), yyS[yypt-0].item.(*ast.WhenClause))
		}
	case 975:
		{
			parser.yyVAL.item = &ast.WhenClause{
				Expr:   yyS[yypt-2].expr,
				Result: yyS[yypt-0].expr,
			}
		}
	case 976:
		{
			parser.yyVAL.item = nil
		}
	case 977:
		{
			parser.yyVAL.item = yyS[yypt-0].expr
		}
	case 978:
		{
			x := types.NewFieldType(mysql.TypeVarString)
			x.Flen = yyS[yypt-0].item.(int) // TODO: Flen should be the flen of expression
			if x.Flen != types.UnspecifiedLength {
				x.Tp = mysql.TypeString
			}
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 979:
		{
			x := types.NewFieldType(mysql.TypeVarString)
			x.Flen = yyS[yypt-1].item.(int) // TODO: Flen should be the flen of expression
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			if x.Charset == "" {
				x.Charset = mysql.DefaultCharset
				x.Collate = mysql.DefaultCollationName
			}
			parser.yyVAL.item = x
		}
	case 980:
		{
			x := types.NewFieldType(mysql.TypeDate)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 981:
		{
			x := types.NewFieldType(mysql.TypeDatetime)
			x.Flen, _ = mysql.GetDefaultFieldLengthAndDecimalForCast(mysql.TypeDatetime)
			x.Decimal = yyS[yypt-0].item.(int)
			if x.Decimal > 0 {
				x.Flen = x.Flen + 1 + x.Decimal
			}
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 982:
		{
			fopt := yyS[yypt-0].item.(*ast.FloatOpt)
			x := types.NewFieldType(mysql.TypeNewDecimal)
			x.Flen = fopt.Flen
			x.Decimal = fopt.Decimal
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 983:
		{
			x := types.NewFieldType(mysql.TypeDuration)
			x.Flen, _ = mysql.GetDefaultFieldLengthAndDecimalForCast(mysql.TypeDuration)
			x.Decimal = yyS[yypt-0].item.(int)
			if x.Decimal > 0 {
				x.Flen = x.Flen + 1 + x.Decimal
			}
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 984:
		{
			x := types.NewFieldType(mysql.TypeLonglong)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 985:
		{
			x := types.NewFieldType(mysql.TypeLonglong)
			x.Flag |= mysql.UnsignedFlag | mysql.BinaryFlag
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			parser.yyVAL.item = x
		}
	case 986:
		{
			x := types.NewFieldType(mysql.TypeJSON)
			x.Flag |= mysql.BinaryFlag | (mysql.ParseToJSONFlag)
			x.Charset = mysql.DefaultCharset
			x.Collate = mysql.DefaultCollationName
			parser.yyVAL.item = x
		}
	case 987:
		{
			x := types.NewFieldType(mysql.TypeDouble)
			x.Flen, x.Decimal = mysql.GetDefaultFieldLengthAndDecimalForCast(mysql.TypeDouble)
			x.Flag |= mysql.BinaryFlag
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			parser.yyVAL.item = x
		}
	case 988:
		{
			x := types.NewFieldType(mysql.TypeFloat)
			fopt := yyS[yypt-0].item.(*ast.FloatOpt)
			if fopt.Flen >= 54 {
				yylex.AppendError(ErrTooBigPrecision.GenWithStackByArgs(fopt.Flen, "CAST", 53))
			} else if fopt.Flen >= 25 {
				x = types.NewFieldType(mysql.TypeDouble)
			}
			x.Flen, x.Decimal = mysql.GetDefaultFieldLengthAndDecimalForCast(x.Tp)
			x.Flag |= mysql.BinaryFlag
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			parser.yyVAL.item = x
		}
	case 989:
		{
			var x *types.FieldType
			if parser.lexer.GetSQLMode().HasRealAsFloatMode() {
				x = types.NewFieldType(mysql.TypeFloat)
			} else {
				x = types.NewFieldType(mysql.TypeDouble)
			}
			x.Flen, x.Decimal = mysql.GetDefaultFieldLengthAndDecimalForCast(x.Tp)
			x.Flag |= mysql.BinaryFlag
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			parser.yyVAL.item = x
		}
	case 990:
		{
			parser.yyVAL.item = mysql.NoPriority
		}
	case 991:
		{
			parser.yyVAL.item = mysql.LowPriority
		}
	case 992:
		{
			parser.yyVAL.item = mysql.HighPriority
		}
	case 993:
		{
			parser.yyVAL.item = mysql.DelayedPriority
		}
	case 994:
		{
			parser.yyVAL.item = &ast.TableName{Name: model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 995:
		{
			parser.yyVAL.item = &ast.TableName{Schema: model.NewCIStr(yyS[yypt-2].ident), Name: model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 996:
		{
			parser.yyVAL.item = &ast.TableName{Name: model.NewCIStr(yyS[yypt-2].ident)}
		}
	case 997:
		{
			tbl := []*ast.TableName{yyS[yypt-0].item.(*ast.TableName)}
			parser.yyVAL.item = tbl
		}
	case 998:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.TableName), yyS[yypt-0].item.(*ast.TableName))
		}
	case 999:
		{
			parser.yyVAL.item = false
		}
	case 1000:
		{
			parser.yyVAL.item = true
		}
	case 1001:
		{
			var sqlText string
			var sqlVar *ast.VariableExpr
			switch yyS[yypt-0].item.(type) {
			case string:
				sqlText = yyS[yypt-0].item.(string)
			case *ast.VariableExpr:
				sqlVar = yyS[yypt-0].item.(*ast.VariableExpr)
			}
			parser.yyVAL.statement = &ast.PrepareStmt{
				Name:    yyS[yypt-2].ident,
				SQLText: sqlText,
				SQLVar:  sqlVar,
			}
		}
	case 1002:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1003:
		{
			parser.yyVAL.item = yyS[yypt-0].expr.(interface{})
		}
	case 1004:
		{
			parser.yyVAL.statement = &ast.ExecuteStmt{Name: yyS[yypt-0].ident}
		}
	case 1005:
		{
			parser.yyVAL.statement = &ast.ExecuteStmt{
				Name:      yyS[yypt-2].ident,
				UsingVars: yyS[yypt-0].item.([]ast.ExprNode),
			}
		}
	case 1006:
		{
			parser.yyVAL.item = []ast.ExprNode{yyS[yypt-0].expr}
		}
	case 1007:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.ExprNode), yyS[yypt-0].expr)
		}
	case 1008:
		{
			parser.yyVAL.statement = &ast.DeallocateStmt{Name: yyS[yypt-0].ident}
		}
	case 1011:
		{
			parser.yyVAL.statement = &ast.RollbackStmt{}
		}
	case 1012:
		{
			st := &ast.SelectStmt{
				SelectStmtOpts: yyS[yypt-1].item.(*ast.SelectStmtOpts),
				Distinct:       yyS[yypt-1].item.(*ast.SelectStmtOpts).Distinct,
				Fields:         yyS[yypt-0].item.(*ast.FieldList),
			}
			if st.SelectStmtOpts.TableHints != nil {
				st.TableHints = st.SelectStmtOpts.TableHints
			}
			parser.yyVAL.item = st
		}
	case 1013:
		{
			st := yyS[yypt-2].item.(*ast.SelectStmt)
			lastField := st.Fields.Fields[len(st.Fields.Fields)-1]
			if lastField.Expr != nil && lastField.AsName.O == "" {
				lastEnd := yyS[yypt-1].offset - 1
				lastField.SetText(parser.src[lastField.Offset:lastEnd])
			}
			if yyS[yypt-0].item != nil {
				st.Where = yyS[yypt-0].item.(ast.ExprNode)
			}
		}
	case 1014:
		{
			st := yyS[yypt-6].item.(*ast.SelectStmt)
			st.From = yyS[yypt-4].item.(*ast.TableRefsClause)
			lastField := st.Fields.Fields[len(st.Fields.Fields)-1]
			if lastField.Expr != nil && lastField.AsName.O == "" {
				lastEnd := parser.endOffset(&yyS[yypt-5])
				lastField.SetText(parser.src[lastField.Offset:lastEnd])
			}
			if yyS[yypt-3].item != nil {
				st.Where = yyS[yypt-3].item.(ast.ExprNode)
			}
			if yyS[yypt-2].item != nil {
				st.GroupBy = yyS[yypt-2].item.(*ast.GroupByClause)
			}
			if yyS[yypt-1].item != nil {
				st.Having = yyS[yypt-1].item.(*ast.HavingClause)
			}
			if yyS[yypt-0].item != nil {
				st.WindowSpecs = (yyS[yypt-0].item.([]ast.WindowSpec))
			}
			parser.yyVAL.item = st
		}
	case 1015:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			lastField := st.Fields.Fields[len(st.Fields.Fields)-1]
			if lastField.Expr != nil && lastField.AsName.O == "" {
				src := parser.src
				var lastEnd int
				if yyS[yypt-2].item != nil {
					lastEnd = yyS[yypt-2].offset - 1
				} else if yyS[yypt-1].item != nil {
					lastEnd = yyS[yypt-1].offset - 1
				} else if yyS[yypt-0].item !=