text:
ast.SelectLockNone {
					lastEnd = yyS[yypt].offset - 1
				} else {
					lastEnd = len(src)
					if src[lastEnd-1] == ';' {
						lastEnd--
					}
				}
				lastField.SetText(src[lastField.Offset:lastEnd])
			}
			if yyS[yypt-2].item != nil {
				st.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				st.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			parser.yyVAL.statement = st
		}
	case 1016:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			if yyS[yypt-2].item != nil {
				st.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				st.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			parser.yyVAL.statement = st
		}
	case 1017:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			if yyS[yypt-2].item != nil {
				st.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				st.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			parser.yyVAL.statement = st
		}
	case 1019:
		{
			parser.yyVAL.item = nil
		}
	case 1020:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]ast.WindowSpec)
		}
	case 1021:
		{
			parser.yyVAL.item = []ast.WindowSpec{yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1022:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.WindowSpec), yyS[yypt-0].item.(ast.WindowSpec))
		}
	case 1023:
		{
			var spec = yyS[yypt-0].item.(ast.WindowSpec)
			spec.Name = yyS[yypt-2].item.(model.CIStr)
			parser.yyVAL.item = spec
		}
	case 1024:
		{
			parser.yyVAL.item = model.NewCIStr(yyS[yypt-0].ident)
		}
	case 1025:
		{
			parser.yyVAL.item = yyS[yypt-1].item.(ast.WindowSpec)
		}
	case 1026:
		{
			spec := ast.WindowSpec{Ref: yyS[yypt-3].item.(model.CIStr)}
			if yyS[yypt-2].item != nil {
				spec.PartitionBy = yyS[yypt-2].item.(*ast.PartitionByClause)
			}
			if yyS[yypt-1].item != nil {
				spec.OrderBy = yyS[yypt-1].item.(*ast.OrderByClause)
			}
			if yyS[yypt-0].item != nil {
				spec.Frame = yyS[yypt-0].item.(*ast.FrameClause)
			}
			parser.yyVAL.item = spec
		}
	case 1027:
		{
			parser.yyVAL.item = model.CIStr{}
		}
	case 1028:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(model.CIStr)
		}
	case 1029:
		{
			parser.yyVAL.item = nil
		}
	case 1030:
		{
			parser.yyVAL.item = &ast.PartitionByClause{Items: yyS[yypt-0].item.([]*ast.ByItem)}
		}
	case 1031:
		{
			parser.yyVAL.item = nil
		}
	case 1032:
		{
			parser.yyVAL.item = &ast.OrderByClause{Items: yyS[yypt-0].item.([]*ast.ByItem)}
		}
	case 1033:
		{
			parser.yyVAL.item = nil
		}
	case 1034:
		{
			parser.yyVAL.item = &ast.FrameClause{
				Type:   yyS[yypt-1].item.(ast.FrameType),
				Extent: yyS[yypt-0].item.(ast.FrameExtent),
			}
		}
	case 1035:
		{
			parser.yyVAL.item = ast.FrameType(ast.Rows)
		}
	case 1036:
		{
			parser.yyVAL.item = ast.FrameType(ast.Ranges)
		}
	case 1037:
		{
			parser.yyVAL.item = ast.FrameType(ast.Groups)
		}
	case 1038:
		{
			parser.yyVAL.item = ast.FrameExtent{
				Start: yyS[yypt-0].item.(ast.FrameBound),
				End:   ast.FrameBound{Type: ast.CurrentRow},
			}
		}
	case 1039:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.FrameExtent)
		}
	case 1040:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Preceding, UnBounded: true}
		}
	case 1041:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Preceding, Expr: ast.NewValueExpr(yyS[yypt-1].item)}
		}
	case 1042:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Preceding, Expr: ast.NewParamMarkerExpr(yyS[yypt].offset)}
		}
	case 1043:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Preceding, Expr: yyS[yypt-2].expr, Unit: yyS[yypt-1].item.(ast.TimeUnitType)}
		}
	case 1044:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.CurrentRow}
		}
	case 1045:
		{
			parser.yyVAL.item = ast.FrameExtent{Start: yyS[yypt-2].item.(ast.FrameBound), End: yyS[yypt-0].item.(ast.FrameBound)}
		}
	case 1046:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.FrameBound)
		}
	case 1047:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Following, UnBounded: true}
		}
	case 1048:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Following, Expr: ast.NewValueExpr(yyS[yypt-1].item)}
		}
	case 1049:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Following, Expr: ast.NewParamMarkerExpr(yyS[yypt].offset)}
		}
	case 1050:
		{
			parser.yyVAL.item = ast.FrameBound{Type: ast.Following, Expr: yyS[yypt-2].expr, Unit: yyS[yypt-1].item.(ast.TimeUnitType)}
		}
	case 1051:
		{
			parser.yyVAL.item = nil
		}
	case 1052:
		{
			spec := yyS[yypt-0].item.(ast.WindowSpec)
			parser.yyVAL.item = &spec
		}
	case 1053:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.WindowSpec)
		}
	case 1054:
		{
			parser.yyVAL.item = ast.WindowSpec{Name: yyS[yypt-0].item.(model.CIStr), OnlyAlias: true}
		}
	case 1055:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.WindowSpec)
		}
	case 1056:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-3].ident, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1057:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-3].ident, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1058:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-3].ident, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1059:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-3].ident, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1060:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-3].ident, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1061:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-4].ident, Args: []ast.ExprNode{yyS[yypt-2].expr}, Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1062:
		{
			args := []ast.ExprNode{yyS[yypt-4].expr}
			if yyS[yypt-3].item != nil {
				args = append(args, yyS[yypt-3].item.([]ast.ExprNode)...)
			}
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-6].ident, Args: args, IgnoreNull: yyS[yypt-1].item.(bool), Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1063:
		{
			args := []ast.ExprNode{yyS[yypt-4].expr}
			if yyS[yypt-3].item != nil {
				args = append(args, yyS[yypt-3].item.([]ast.ExprNode)...)
			}
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-6].ident, Args: args, IgnoreNull: yyS[yypt-1].item.(bool), Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1064:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-3].expr}, IgnoreNull: yyS[yypt-1].item.(bool), Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1065:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-5].ident, Args: []ast.ExprNode{yyS[yypt-3].expr}, IgnoreNull: yyS[yypt-1].item.(bool), Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1066:
		{
			parser.yyVAL.item = &ast.WindowFuncExpr{F: yyS[yypt-8].ident, Args: []ast.ExprNode{yyS[yypt-6].expr, yyS[yypt-4].expr}, FromLast: yyS[yypt-2].item.(bool), IgnoreNull: yyS[yypt-1].item.(bool), Spec: yyS[yypt-0].item.(ast.WindowSpec)}
		}
	case 1067:
		{
			parser.yyVAL.item = nil
		}
	case 1068:
		{
			args := []ast.ExprNode{ast.NewValueExpr(yyS[yypt-1].item)}
			if yyS[yypt-0].item != nil {
				args = append(args, yyS[yypt-0].item.(ast.ExprNode))
			}
			parser.yyVAL.item = args
		}
	case 1069:
		{
			args := []ast.ExprNode{ast.NewValueExpr(yyS[yypt-1].item)}
			if yyS[yypt-0].item != nil {
				args = append(args, yyS[yypt-0].item.(ast.ExprNode))
			}
			parser.yyVAL.item = args
		}
	case 1070:
		{
			parser.yyVAL.item = nil
		}
	case 1071:
		{
			parser.yyVAL.item = yyS[yypt-0].expr
		}
	case 1072:
		{
			parser.yyVAL.item = false
		}
	case 1073:
		{
			parser.yyVAL.item = false
		}
	case 1074:
		{
			parser.yyVAL.item = true
		}
	case 1075:
		{
			parser.yyVAL.item = false
		}
	case 1076:
		{
			parser.yyVAL.item = false
		}
	case 1077:
		{
			parser.yyVAL.item = true
		}
	case 1078:
		{
			parser.yyVAL.item = &ast.TableRefsClause{TableRefs: yyS[yypt-0].item.(*ast.Join)}
		}
	case 1079:
		{
			if j, ok := yyS[yypt-0].item.(*ast.Join); ok {
				// if $1 is Join, use it directly
				parser.yyVAL.item = j
			} else {
				parser.yyVAL.item = &ast.Join{Left: yyS[yypt-0].item.(ast.ResultSetNode), Right: nil}
			}
		}
	case 1080:
		{
			/* from a, b is default cross join */
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-2].item.(ast.ResultSetNode), Right: yyS[yypt-0].item.(ast.ResultSetNode), Tp: ast.CrossJoin}
		}
	case 1081:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1082:
		{
			/*
			* ODBC escape syntax for outer join is { OJ join_table }
			* Use an Identifier for OJ
			 */
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 1083:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1084:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1085:
		{
			tn := yyS[yypt-3].item.(*ast.TableName)
			tn.PartitionNames = yyS[yypt-2].item.([]model.CIStr)
			tn.IndexHints = yyS[yypt-0].item.([]*ast.IndexHint)
			parser.yyVAL.item = &ast.TableSource{Source: tn, AsName: yyS[yypt-1].item.(model.CIStr)}
		}
	case 1086:
		{
			st := yyS[yypt-2].statement.(*ast.SelectStmt)
			endOffset := parser.endOffset(&yyS[yypt-1])
			parser.setLastSelectFieldText(st, endOffset)
			parser.yyVAL.item = &ast.TableSource{Source: yyS[yypt-2].statement.(*ast.SelectStmt), AsName: yyS[yypt-0].item.(model.CIStr)}
		}
	case 1087:
		{
			parser.yyVAL.item = &ast.TableSource{Source: yyS[yypt-2].statement.(*ast.UnionStmt), AsName: yyS[yypt-0].item.(model.CIStr)}
		}
	case 1088:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 1089:
		{
			parser.yyVAL.item = []model.CIStr{}
		}
	case 1090:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 1091:
		{
			parser.yyVAL.item = model.CIStr{}
		}
	case 1092:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1093:
		{
			parser.yyVAL.item = model.NewCIStr(yyS[yypt-0].ident)
		}
	case 1094:
		{
			parser.yyVAL.item = model.NewCIStr(yyS[yypt-0].ident)
		}
	case 1095:
		{
			parser.yyVAL.item = ast.HintUse
		}
	case 1096:
		{
			parser.yyVAL.item = ast.HintIgnore
		}
	case 1097:
		{
			parser.yyVAL.item = ast.HintForce
		}
	case 1098:
		{
			parser.yyVAL.item = ast.HintForScan
		}
	case 1099:
		{
			parser.yyVAL.item = ast.HintForJoin
		}
	case 1100:
		{
			parser.yyVAL.item = ast.HintForOrderBy
		}
	case 1101:
		{
			parser.yyVAL.item = ast.HintForGroupBy
		}
	case 1102:
		{
			parser.yyVAL.item = &ast.IndexHint{
				IndexNames: yyS[yypt-1].item.([]model.CIStr),
				HintType:   yyS[yypt-4].item.(ast.IndexHintType),
				HintScope:  yyS[yypt-3].item.(ast.IndexHintScope),
			}
		}
	case 1103:
		{
			var nameList []model.CIStr
			parser.yyVAL.item = nameList
		}
	case 1104:
		{
			parser.yyVAL.item = []model.CIStr{model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 1105:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]model.CIStr), model.NewCIStr(yyS[yypt-0].ident))
		}
	case 1106:
		{
			parser.yyVAL.item = []model.CIStr{model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 1107:
		{
			parser.yyVAL.item = []*ast.IndexHint{yyS[yypt-0].item.(*ast.IndexHint)}
		}
	case 1108:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.IndexHint), yyS[yypt-0].item.(*ast.IndexHint))
		}
	case 1109:
		{
			var hintList []*ast.IndexHint
			parser.yyVAL.item = hintList
		}
	case 1110:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1111:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-2].item.(ast.ResultSetNode), Right: yyS[yypt-0].item.(ast.ResultSetNode), Tp: ast.CrossJoin}
		}
	case 1112:
		{
			on := &ast.OnCondition{Expr: yyS[yypt-0].expr}
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-4].item.(ast.ResultSetNode), Right: yyS[yypt-2].item.(ast.ResultSetNode), Tp: ast.CrossJoin, On: on}
		}
	case 1113:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-6].item.(ast.ResultSetNode), Right: yyS[yypt-4].item.(ast.ResultSetNode), Tp: ast.CrossJoin, Using: yyS[yypt-1].item.([]*ast.ColumnName)}
		}
	case 1114:
		{
			on := &ast.OnCondition{Expr: yyS[yypt-0].expr}
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-6].item.(ast.ResultSetNode), Right: yyS[yypt-2].item.(ast.ResultSetNode), Tp: yyS[yypt-5].item.(ast.JoinType), On: on}
		}
	case 1115:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-8].item.(ast.ResultSetNode), Right: yyS[yypt-4].item.(ast.ResultSetNode), Tp: yyS[yypt-7].item.(ast.JoinType), Using: yyS[yypt-1].item.([]*ast.ColumnName)}
		}
	case 1116:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-3].item.(ast.ResultSetNode), Right: yyS[yypt-0].item.(ast.ResultSetNode), NaturalJoin: true}
		}
	case 1117:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-5].item.(ast.ResultSetNode), Right: yyS[yypt-0].item.(ast.ResultSetNode), Tp: yyS[yypt-3].item.(ast.JoinType), NaturalJoin: true}
		}
	case 1118:
		{
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-2].item.(ast.ResultSetNode), Right: yyS[yypt-0].item.(ast.ResultSetNode), StraightJoin: true}
		}
	case 1119:
		{
			on := &ast.OnCondition{Expr: yyS[yypt-0].expr}
			parser.yyVAL.item = &ast.Join{Left: yyS[yypt-4].item.(ast.ResultSetNode), Right: yyS[yypt-2].item.(ast.ResultSetNode), StraightJoin: true, On: on}
		}
	case 1120:
		{
			parser.yyVAL.item = ast.LeftJoin
		}
	case 1121:
		{
			parser.yyVAL.item = ast.RightJoin
		}
	case 1127:
		{
			parser.yyVAL.item = nil
		}
	case 1128:
		{
			parser.yyVAL.item = &ast.Limit{Count: yyS[yypt-0].item.(ast.ValueExpr)}
		}
	case 1129:
		{
			parser.yyVAL.item = ast.NewValueExpr(yyS[yypt-0].item)
		}
	case 1130:
		{
			parser.yyVAL.item = ast.NewParamMarkerExpr(yyS[yypt].offset)
		}
	case 1131:
		{
			parser.yyVAL.item = nil
		}
	case 1132:
		{
			parser.yyVAL.item = &ast.Limit{Count: yyS[yypt-0].item.(ast.ExprNode)}
		}
	case 1133:
		{
			parser.yyVAL.item = &ast.Limit{Offset: yyS[yypt-2].item.(ast.ExprNode), Count: yyS[yypt-0].item.(ast.ExprNode)}
		}
	case 1134:
		{
			parser.yyVAL.item = &ast.Limit{Offset: yyS[yypt-0].item.(ast.ExprNode), Count: yyS[yypt-2].item.(ast.ExprNode)}
		}
	case 1135:
		{
			opt := &ast.SelectStmtOpts{}
			if yyS[yypt-8].item != nil {
				opt.TableHints = yyS[yypt-8].item.([]*ast.TableOptimizerHint)
			}
			if yyS[yypt-7].item != nil {
				opt.Distinct = yyS[yypt-7].item.(bool)
			}
			if yyS[yypt-6].item != nil {
				opt.Priority = yyS[yypt-6].item.(mysql.PriorityEnum)
			}
			if yyS[yypt-5].item != nil {
				opt.SQLSmallResult = yyS[yypt-5].item.(bool)
			}
			if yyS[yypt-4].item != nil {
				opt.SQLBigResult = yyS[yypt-4].item.(bool)
			}
			if yyS[yypt-3].item != nil {
				opt.SQLBufferResult = yyS[yypt-3].item.(bool)
			}
			if yyS[yypt-2].item != nil {
				opt.SQLCache = yyS[yypt-2].item.(bool)
			}
			if yyS[yypt-1].item != nil {
				opt.CalcFoundRows = yyS[yypt-1].item.(bool)
			}
			if yyS[yypt-0].item != nil {
				opt.StraightJoin = yyS[yypt-0].item.(bool)
			}

			parser.yyVAL.item = opt
		}
	case 1136:
		{
			parser.yyVAL.item = nil
		}
	case 1137:
		{
			parser.yyVAL.item = yyS[yypt-1].item
		}
	case 1138:
		{
			yyerrok()
			parser.lastErrorAsWarn()
			parser.yyVAL.item = nil
		}
	case 1139:
		{
			parser.yyVAL.item = []model.CIStr{model.NewCIStr(yyS[yypt-0].ident)}
		}
	case 1140:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]model.CIStr), model.NewCIStr(yyS[yypt-0].ident))
		}
	case 1141:
		{
			parser.yyVAL.item = []*ast.TableOptimizerHint{yyS[yypt-0].item.(*ast.TableOptimizerHint)}
		}
	case 1142:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.TableOptimizerHint), yyS[yypt-0].item.(*ast.TableOptimizerHint))
		}
	case 1143:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-3].ident), Tables: yyS[yypt-1].item.([]model.CIStr)}
		}
	case 1144:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-3].ident), Tables: yyS[yypt-1].item.([]model.CIStr)}
		}
	case 1145:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-3].ident), Tables: yyS[yypt-1].item.([]model.CIStr)}
		}
	case 1146:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-2].ident)}
		}
	case 1147:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-2].ident)}
		}
	case 1148:
		{
			parser.yyVAL.item = &ast.TableOptimizerHint{HintName: model.NewCIStr(yyS[yypt-3].ident), MaxExecutionTime: getUint64FromNUM(yyS[yypt-1].item)}
		}
	case 1149:
		{
			parser.yyVAL.item = false
		}
	case 1150:
		{
			parser.yyVAL.item = true
		}
	case 1151:
		{
			parser.yyVAL.item = false
		}
	case 1152:
		{
			parser.yyVAL.item = true
		}
	case 1153:
		{
			parser.yyVAL.item = false
		}
	case 1154:
		{
			parser.yyVAL.item = true
		}
	case 1155:
		{
			parser.yyVAL.item = true
		}
	case 1156:
		{
			parser.yyVAL.item = true
		}
	case 1157:
		{
			parser.yyVAL.item = false
		}
	case 1158:
		{
			parser.yyVAL.item = false
		}
	case 1159:
		{
			parser.yyVAL.item = true
		}
	case 1160:
		{
			parser.yyVAL.item = false
		}
	case 1161:
		{
			parser.yyVAL.item = true
		}
	case 1162:
		{
			parser.yyVAL.item = &ast.FieldList{Fields: yyS[yypt-0].item.([]*ast.SelectField)}
		}
	case 1163:
		{
			parser.yyVAL.item = nil
		}
	case 1165:
		{
			s := yyS[yypt-1].statement.(*ast.SelectStmt)
			endOffset := parser.endOffset(&yyS[yypt])
			parser.setLastSelectFieldText(s, endOffset)
			src := parser.src
			// See the implementation of yyParse function
			s.SetText(src[yyS[yypt-1].offset:yyS[yypt].offset])
			parser.yyVAL.expr = &ast.SubqueryExpr{Query: s}
		}
	case 1166:
		{
			s := yyS[yypt-1].statement.(*ast.UnionStmt)
			src := parser.src
			// See the implementation of yyParse function
			s.SetText(src[yyS[yypt-1].offset:yyS[yypt].offset])
			parser.yyVAL.expr = &ast.SubqueryExpr{Query: s}
		}
	case 1167:
		{
			parser.yyVAL.item = ast.SelectLockNone
		}
	case 1168:
		{
			parser.yyVAL.item = ast.SelectLockForUpdate
		}
	case 1169:
		{
			parser.yyVAL.item = ast.SelectLockInShareMode
		}
	case 1170:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			union := yyS[yypt-6].item.(*ast.UnionStmt)
			st.IsAfterUnionDistinct = yyS[yypt-4].item.(bool)
			lastSelect := union.SelectList.Selects[len(union.SelectList.Selects)-1]
			endOffset := parser.endOffset(&yyS[yypt-5])
			parser.setLastSelectFieldText(lastSelect, endOffset)
			union.SelectList.Selects = append(union.SelectList.Selects, st)
			if yyS[yypt-2].item != nil {
				union.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				union.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			if yyS[yypt-2].item == nil && yyS[yypt-1].item == nil {
				st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			}
			parser.yyVAL.statement = union
		}
	case 1171:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			union := yyS[yypt-6].item.(*ast.UnionStmt)
			st.IsAfterUnionDistinct = yyS[yypt-4].item.(bool)
			lastSelect := union.SelectList.Selects[len(union.SelectList.Selects)-1]
			endOffset := parser.endOffset(&yyS[yypt-5])
			parser.setLastSelectFieldText(lastSelect, endOffset)
			union.SelectList.Selects = append(union.SelectList.Selects, st)
			if yyS[yypt-2].item != nil {
				union.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				union.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			if yyS[yypt-2].item == nil && yyS[yypt-1].item == nil {
				st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			}
			parser.yyVAL.statement = union
		}
	case 1172:
		{
			st := yyS[yypt-3].item.(*ast.SelectStmt)
			union := yyS[yypt-6].item.(*ast.UnionStmt)
			st.IsAfterUnionDistinct = yyS[yypt-4].item.(bool)
			lastSelect := union.SelectList.Selects[len(union.SelectList.Selects)-1]
			endOffset := parser.endOffset(&yyS[yypt-5])
			parser.setLastSelectFieldText(lastSelect, endOffset)
			union.SelectList.Selects = append(union.SelectList.Selects, st)
			if yyS[yypt-2].item != nil {
				union.OrderBy = yyS[yypt-2].item.(*ast.OrderByClause)
			}
			if yyS[yypt-1].item != nil {
				union.Limit = yyS[yypt-1].item.(*ast.Limit)
			}
			if yyS[yypt-2].item == nil && yyS[yypt-1].item == nil {
				st.LockTp = yyS[yypt-0].item.(ast.SelectLockType)
			}
			parser.yyVAL.statement = union
		}
	case 1173:
		{
			union := yyS[yypt-7].item.(*ast.UnionStmt)
			lastSelect := union.SelectList.Selects[len(union.SelectList.Selects)-1]
			endOffset := parser.endOffset(&yyS[yypt-6])
			parser.setLastSelectFieldText(lastSelect, endOffset)
			st := yyS[yypt-3].statement.(*ast.SelectStmt)
			st.IsInBraces = true
			st.IsAfterUnionDistinct = yyS[yypt-5].item.(bool)
			endOffset = parser.endOffset(&yyS[yypt-2])
			parser.setLastSelectFieldText(st, endOffset)
			union.SelectList.Selects = append(union.SelectList.Selects, st)
			if yyS[yypt-1].item != nil {
				union.OrderBy = yyS[yypt-1].item.(*ast.OrderByClause)
			}
			if yyS[yypt-0].item != nil {
				union.Limit = yyS[yypt-0].item.(*ast.Limit)
			}
			parser.yyVAL.statement = union
		}
	case 1174:
		{
			selectList := &ast.UnionSelectList{Selects: []*ast.SelectStmt{yyS[yypt-0].item.(*ast.SelectStmt)}}
			parser.yyVAL.item = &ast.UnionStmt{
				SelectList: selectList,
			}
		}
	case 1175:
		{
			union := yyS[yypt-3].item.(*ast.UnionStmt)
			st := yyS[yypt-0].item.(*ast.SelectStmt)
			st.IsAfterUnionDistinct = yyS[yypt-1].item.(bool)
			lastSelect := union.SelectList.Selects[len(union.SelectList.Selects)-1]
			endOffset := parser.endOffset(&yyS[yypt-2])
			parser.setLastSelectFieldText(lastSelect, endOffset)
			union.SelectList.Selects = append(union.SelectList.Selects, st)
			parser.yyVAL.item = union
		}
	case 1176:
		{
			parser.yyVAL.item = yyS[yypt-0].statement.(interface{})
		}
	case 1177:
		{
			st := yyS[yypt-1].statement.(*ast.SelectStmt)
			st.IsInBraces = true
			endOffset := parser.endOffset(&yyS[yypt])
			parser.setLastSelectFieldText(st, endOffset)
			parser.yyVAL.item = yyS[yypt-1].statement
		}
	case 1179:
		{
			parser.yyVAL.statement = &ast.ChangeStmt{
				NodeType: ast.PumpType,
				State:    yyS[yypt-3].ident,
				NodeID:   yyS[yypt-0].ident,
			}
		}
	case 1180:
		{
			parser.yyVAL.statement = &ast.ChangeStmt{
				NodeType: ast.DrainerType,
				State:    yyS[yypt-3].ident,
				NodeID:   yyS[yypt-0].ident,
			}
		}
	case 1181:
		{
			parser.yyVAL.statement = &ast.SetStmt{Variables: yyS[yypt-0].item.([]*ast.VariableAssignment)}
		}
	case 1182:
		{
			parser.yyVAL.statement = &ast.SetPwdStmt{Password: yyS[yypt-0].item.(string)}
		}
	case 1183:
		{
			parser.yyVAL.statement = &ast.SetPwdStmt{User: yyS[yypt-2].item.(*auth.UserIdentity), Password: yyS[yypt-0].item.(string)}
		}
	case 1184:
		{
			vars := yyS[yypt-0].item.([]*ast.VariableAssignment)
			for _, v := range vars {
				v.IsGlobal = true
			}
			parser.yyVAL.statement = &ast.SetStmt{Variables: vars}
		}
	case 1185:
		{
			parser.yyVAL.statement = &ast.SetStmt{Variables: yyS[yypt-0].item.([]*ast.VariableAssignment)}
		}
	case 1186:
		{
			assigns := yyS[yypt-0].item.([]*ast.VariableAssignment)
			for i := 0; i < len(assigns); i++ {
				if assigns[i].Name == "tx_isolation" {
					// A special session variable that make setting tx_isolation take effect one time.
					assigns[i].Name = "tx_isolation_one_shot"
				}
			}
			parser.yyVAL.statement = &ast.SetStmt{Variables: assigns}
		}
	case 1187:
		{
			parser.yyVAL.statement = yyS[yypt-0].item.(*ast.SetRoleStmt)
		}
	case 1188:
		{
			tmp := yyS[yypt-2].item.(*ast.SetRoleStmt)
			parser.yyVAL.statement = &ast.SetDefaultRoleStmt{
				SetRoleOpt: tmp.SetRoleOpt,
				RoleList:   tmp.RoleList,
				UserList:   yyS[yypt-0].item.([]*auth.UserIdentity),
			}
		}
	case 1189:
		{
			parser.yyVAL.item = &ast.SetRoleStmt{SetRoleOpt: ast.SetRoleNone, RoleList: nil}
		}
	case 1190:
		{
			parser.yyVAL.item = &ast.SetRoleStmt{SetRoleOpt: ast.SetRoleAll, RoleList: nil}
		}
	case 1191:
		{
			parser.yyVAL.item = &ast.SetRoleStmt{SetRoleOpt: ast.SetRoleRegular, RoleList: yyS[yypt-0].item.([]*auth.RoleIdentity)}
		}
	case 1192:
		{
			parser.yyVAL.item = &ast.SetRoleStmt{SetRoleOpt: ast.SetRoleAllExcept, RoleList: yyS[yypt-0].item.([]*auth.RoleIdentity)}
		}
	case 1193:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1194:
		{
			parser.yyVAL.item = &ast.SetRoleStmt{SetRoleOpt: ast.SetRoleDefault, RoleList: nil}
		}
	case 1195:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.item = yyS[yypt-0].item
			} else {
				parser.yyVAL.item = []*ast.VariableAssignment{}
			}
		}
	case 1196:
		{
			if yyS[yypt-0].item != nil {
				varAssigns := yyS[yypt-0].item.([]*ast.VariableAssignment)
				parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.VariableAssignment), varAssigns...)
			} else {
				parser.yyVAL.item = yyS[yypt-2].item
			}
		}
	case 1197:
		{
			varAssigns := []*ast.VariableAssignment{}
			expr := ast.NewValueExpr(yyS[yypt-0].ident)
			varAssigns = append(varAssigns, &ast.VariableAssignment{Name: "tx_isolation", Value: expr, IsSystem: true})
			parser.yyVAL.item = varAssigns
		}
	case 1198:
		{
			varAssigns := []*ast.VariableAssignment{}
			expr := ast.NewValueExpr("0")
			varAssigns = append(varAssigns, &ast.VariableAssignment{Name: "tx_read_only", Value: expr, IsSystem: true})
			parser.yyVAL.item = varAssigns
		}
	case 1199:
		{
			varAssigns := []*ast.VariableAssignment{}
			expr := ast.NewValueExpr("1")
			varAssigns = append(varAssigns, &ast.VariableAssignment{Name: "tx_read_only", Value: expr, IsSystem: true})
			parser.yyVAL.item = varAssigns
		}
	case 1200:
		{
			parser.yyVAL.ident = ast.RepeatableRead
		}
	case 1201:
		{
			parser.yyVAL.ident = ast.ReadCommitted
		}
	case 1202:
		{
			parser.yyVAL.ident = ast.ReadUncommitted
		}
	case 1203:
		{
			parser.yyVAL.ident = ast.Serializable
		}
	case 1204:
		{
			parser.yyVAL.expr = ast.NewValueExpr("ON")
		}
	case 1208:
		{
			parser.yyVAL.item = &ast.VariableAssignment{Name: yyS[yypt-2].ident, Value: yyS[yypt-0].expr, IsSystem: true}
		}
	case 1209:
		{
			parser.yyVAL.item = &ast.VariableAssignment{Name: yyS[yypt-2].ident, Value: yyS[yypt-0].expr, IsGlobal: true, IsSystem: true}
		}
	case 1210:
		{
			parser.yyVAL.item = &ast.VariableAssignment{Name: yyS[yypt-2].ident, Value: yyS[yypt-0].expr, IsSystem: true}
		}
	case 1211:
		{
			parser.yyVAL.item = &ast.VariableAssignment{Name: yyS[yypt-2].ident, Value: yyS[yypt-0].expr, IsSystem: true}
		}
	case 1212:
		{
			v := strings.ToLower(yyS[yypt-2].ident)
			var isGlobal bool
			if strings.HasPrefix(v, "@@global.") {
				isGlobal = true
				v = strings.TrimPrefix(v, "@@global.")
			} else if strings.HasPrefix(v, "@@session.") {
				v = strings.TrimPrefix(v, "@@session.")
			} else if strings.HasPrefix(v, "@@local.") {
				v = strings.TrimPrefix(v, "@@local.")
			} else if strings.HasPrefix(v, "@@") {
				v = strings.TrimPrefix(v, "@@")
			}
			parser.yyVAL.item = &ast.VariableAssignment{Name: v, Value: yyS[yypt-0].expr, IsGlobal: isGlobal, IsSystem: true}
		}
	case 1213:
		{
			v := yyS[yypt-2].ident
			v = strings.TrimPrefix(v, "@")
			parser.yyVAL.item = &ast.VariableAssignment{Name: v, Value: yyS[yypt-0].expr}
		}
	case 1214:
		{
			parser.yyVAL.item = &ast.VariableAssignment{
				Name:  ast.SetNames,
				Value: ast.NewValueExpr(yyS[yypt-0].item.(string)),
			}
		}
	case 1215:
		{
			parser.yyVAL.item = &ast.VariableAssignment{
				Name:  ast.SetNames,
				Value: ast.NewValueExpr(yyS[yypt-2].item.(string)),
			}
		}
	case 1216:
		{
			parser.yyVAL.item = &ast.VariableAssignment{
				Name:        ast.SetNames,
				Value:       ast.NewValueExpr(yyS[yypt-2].item.(string)),
				ExtendValue: ast.NewValueExpr(yyS[yypt-0].item.(string)),
			}
		}
	case 1217:
		{
			parser.yyVAL.item = &ast.VariableAssignment{
				Name:  ast.SetNames,
				Value: ast.NewValueExpr(yyS[yypt-0].item.(string)),
			}
		}
	case 1218:
		{
			// Validate input charset name to keep the same behavior as parser of MySQL.
			name, _, err := charset.GetCharsetInfo(yyS[yypt-0].item.(string))
			if err != nil {
				yylex.AppendError(ErrUnknownCharacterSet.GenWithStackByArgs(yyS[yypt-0].item))
				return 1
			}
			// Use charset name returned from charset.GetCharsetInfo(),
			// to keep lower case of input for generated column restore.
			parser.yyVAL.item = name
		}
	case 1219:
		{
			parser.yyVAL.item = charset.CharsetBin
		}
	case 1220:
		{
			info, err := charset.GetCollationByName(yyS[yypt-0].item.(string))
			if err != nil {
				yylex.AppendError(err)
				return 1
			}
			parser.yyVAL.item = info.Name
		}
	case 1221:
		{
			parser.yyVAL.item = []*ast.VariableAssignment{}
		}
	case 1222:
		{
			parser.yyVAL.item = []*ast.VariableAssignment{yyS[yypt-0].item.(*ast.VariableAssignment)}
		}
	case 1223:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.VariableAssignment), yyS[yypt-0].item.(*ast.VariableAssignment))
		}
	case 1226:
		{
			v := strings.ToLower(yyS[yypt-0].ident)
			var isGlobal bool
			explicitScope := true
			if strings.HasPrefix(v, "@@global.") {
				isGlobal = true
				v = strings.TrimPrefix(v, "@@global.")
			} else if strings.HasPrefix(v, "@@session.") {
				v = strings.TrimPrefix(v, "@@session.")
			} else if strings.HasPrefix(v, "@@local.") {
				v = strings.TrimPrefix(v, "@@local.")
			} else if strings.HasPrefix(v, "@@") {
				v, explicitScope = strings.TrimPrefix(v, "@@"), false
			}
			parser.yyVAL.expr = &ast.VariableExpr{Name: v, IsGlobal: isGlobal, IsSystem: true, ExplicitScope: explicitScope}
		}
	case 1227:
		{
			v := yyS[yypt-0].ident
			v = strings.TrimPrefix(v, "@")
			parser.yyVAL.expr = &ast.VariableExpr{Name: v, IsGlobal: false, IsSystem: false}
		}
	case 1228:
		{
			parser.yyVAL.item = &auth.UserIdentity{Username: yyS[yypt-0].item.(string), Hostname: "%"}
		}
	case 1229:
		{
			parser.yyVAL.item = &auth.UserIdentity{Username: yyS[yypt-2].item.(string), Hostname: yyS[yypt-0].item.(string)}
		}
	case 1230:
		{
			parser.yyVAL.item = &auth.UserIdentity{Username: yyS[yypt-1].item.(string), Hostname: strings.TrimPrefix(yyS[yypt-0].ident, "@")}
		}
	case 1231:
		{
			parser.yyVAL.item = &auth.UserIdentity{CurrentUser: true}
		}
	case 1232:
		{
			parser.yyVAL.item = []*auth.UserIdentity{yyS[yypt-0].item.(*auth.UserIdentity)}
		}
	case 1233:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*auth.UserIdentity), yyS[yypt-0].item.(*auth.UserIdentity))
		}
	case 1234:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1235:
		{
			parser.yyVAL.item = yyS[yypt-1].item.(string)
		}
	case 1236:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1237:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1238:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1239:
		{
			parser.yyVAL.item = &auth.RoleIdentity{Username: yyS[yypt-0].item.(string), Hostname: "%"}
		}
	case 1240:
		{
			parser.yyVAL.item = &auth.RoleIdentity{Username: yyS[yypt-2].item.(string), Hostname: yyS[yypt-0].item.(string)}
		}
	case 1241:
		{
			parser.yyVAL.item = &auth.RoleIdentity{Username: yyS[yypt-1].item.(string), Hostname: strings.TrimPrefix(yyS[yypt-0].ident, "@")}
		}
	case 1242:
		{
			parser.yyVAL.item = []*auth.RoleIdentity{yyS[yypt-0].item.(*auth.RoleIdentity)}
		}
	case 1243:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*auth.RoleIdentity), yyS[yypt-0].item.(*auth.RoleIdentity))
		}
	case 1244:
		{
			parser.yyVAL.statement = &ast.AdminStmt{Tp: ast.AdminShowDDL}
		}
	case 1245:
		{
			parser.yyVAL.statement = &ast.AdminStmt{Tp: ast.AdminShowDDLJobs}
		}
	case 1246:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:        ast.AdminShowDDLJobs,
				JobNumber: yyS[yypt-0].item.(int64),
			}
		}
	case 1247:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminShowNextRowID,
				Tables: []*ast.TableName{yyS[yypt-1].item.(*ast.TableName)},
			}
		}
	case 1248:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminCheckTable,
				Tables: yyS[yypt-0].item.([]*ast.TableName),
			}
		}
	case 1249:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminCheckIndex,
				Tables: []*ast.TableName{yyS[yypt-1].item.(*ast.TableName)},
				Index:  string(yyS[yypt-0].ident),
			}
		}
	case 1250:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminRecoverIndex,
				Tables: []*ast.TableName{yyS[yypt-1].item.(*ast.TableName)},
				Index:  string(yyS[yypt-0].ident),
			}
		}
	case 1251:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminCleanupIndex,
				Tables: []*ast.TableName{yyS[yypt-1].item.(*ast.TableName)},
				Index:  string(yyS[yypt-0].ident),
			}
		}
	case 1252:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:           ast.AdminCheckIndexRange,
				Tables:       []*ast.TableName{yyS[yypt-2].item.(*ast.TableName)},
				Index:        string(yyS[yypt-1].ident),
				HandleRanges: yyS[yypt-0].item.([]ast.HandleRange),
			}
		}
	case 1253:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminChecksumTable,
				Tables: yyS[yypt-0].item.([]*ast.TableName),
			}
		}
	case 1254:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminCancelDDLJobs,
				JobIDs: yyS[yypt-0].item.([]int64),
			}
		}
	case 1255:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:     ast.AdminShowDDLJobQueries,
				JobIDs: yyS[yypt-0].item.([]int64),
			}
		}
	case 1256:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:       ast.AdminShowSlow,
				ShowSlow: yyS[yypt-0].item.(*ast.ShowSlow),
			}
		}
	case 1257:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp: ast.AdminReloadExprPushdownBlacklist,
			}
		}
	case 1258:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp: ast.AdminReloadOptRuleBlacklist,
			}
		}
	case 1259:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:      ast.AdminPluginEnable,
				Plugins: yyS[yypt-0].item.([]string),
			}
		}
	case 1260:
		{
			parser.yyVAL.statement = &ast.AdminStmt{
				Tp:      ast.AdminPluginDisable,
				Plugins: yyS[yypt-0].item.([]string),
			}
		}
	case 1261:
		{
			parser.yyVAL.statement = &ast.CleanupTableLockStmt{
				Tables: yyS[yypt-0].item.([]*ast.TableName),
			}
		}
	case 1262:
		{
			parser.yyVAL.item = &ast.ShowSlow{
				Tp:    ast.ShowSlowRecent,
				Count: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 1263:
		{
			parser.yyVAL.item = &ast.ShowSlow{
				Tp:    ast.ShowSlowTop,
				Kind:  ast.ShowSlowKindDefault,
				Count: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 1264:
		{
			parser.yyVAL.item = &ast.ShowSlow{
				Tp:    ast.ShowSlowTop,
				Kind:  ast.ShowSlowKindInternal,
				Count: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 1265:
		{
			parser.yyVAL.item = &ast.ShowSlow{
				Tp:    ast.ShowSlowTop,
				Kind:  ast.ShowSlowKindAll,
				Count: getUint64FromNUM(yyS[yypt-0].item),
			}
		}
	case 1266:
		{
			parser.yyVAL.item = []ast.HandleRange{yyS[yypt-0].item.(ast.HandleRange)}
		}
	case 1267:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.HandleRange), yyS[yypt-0].item.(ast.HandleRange))
		}
	case 1268:
		{
			parser.yyVAL.item = ast.HandleRange{Begin: yyS[yypt-3].item.(int64), End: yyS[yypt-1].item.(int64)}
		}
	case 1269:
		{
			parser.yyVAL.item = []int64{yyS[yypt-0].item.(int64)}
		}
	case 1270:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]int64), yyS[yypt-0].item.(int64))
		}
	case 1271:
		{
			stmt := yyS[yypt-1].item.(*ast.ShowStmt)
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1272:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:    ast.ShowCreateTable,
				Table: yyS[yypt-0].item.(*ast.TableName),
			}
		}
	case 1273:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:    ast.ShowCreateView,
				Table: yyS[yypt-0].item.(*ast.TableName),
			}
		}
	case 1274:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:          ast.ShowCreateDatabase,
				IfNotExists: yyS[yypt-1].item.(bool),
				DBName:      yyS[yypt-0].item.(string),
			}
		}
	case 1275:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/show-create-user.html
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:   ast.ShowCreateUser,
				User: yyS[yypt-0].item.(*auth.UserIdentity),
			}
		}
	case 1276:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:    ast.ShowRegions,
				Table: yyS[yypt-1].item.(*ast.TableName),
			}
		}
	case 1277:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:        ast.ShowRegions,
				Table:     yyS[yypt-3].item.(*ast.TableName),
				IndexName: model.NewCIStr(yyS[yypt-1].ident),
			}
		}
	case 1278:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/show-grants.html
			parser.yyVAL.statement = &ast.ShowStmt{Tp: ast.ShowGrants}
		}
	case 1279:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/show-grants.html
			if yyS[yypt-0].item != nil {
				parser.yyVAL.statement = &ast.ShowStmt{
					Tp:    ast.ShowGrants,
					User:  yyS[yypt-1].item.(*auth.UserIdentity),
					Roles: yyS[yypt-0].item.([]*auth.RoleIdentity),
				}
			} else {
				parser.yyVAL.statement = &ast.ShowStmt{
					Tp:    ast.ShowGrants,
					User:  yyS[yypt-1].item.(*auth.UserIdentity),
					Roles: nil,
				}
			}
		}
	case 1280:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp: ast.ShowMasterStatus,
			}
		}
	case 1281:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp:   ast.ShowProcessList,
				Full: yyS[yypt-1].item.(bool),
			}
		}
	case 1282:
		{
			stmt := &ast.ShowStmt{
				Tp: ast.ShowStatsMeta,
			}
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1283:
		{
			stmt := &ast.ShowStmt{
				Tp: ast.ShowStatsHistograms,
			}
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1284:
		{
			stmt := &ast.ShowStmt{
				Tp: ast.ShowStatsBuckets,
			}
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1285:
		{
			stmt := &ast.ShowStmt{
				Tp: ast.ShowStatsHealthy,
			}
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1286:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp: ast.ShowProfiles,
			}
		}
	case 1287:
		{
			v := &ast.ShowStmt{
				Tp: ast.ShowProfile,
			}
			if yyS[yypt-2].item != nil {
				v.ShowProfileTypes = yyS[yypt-2].item.([]int)
			}
			if yyS[yypt-1].item != nil {
				v.ShowProfileArgs = yyS[yypt-1].item.(*int64)
			}
			if yyS[yypt-0].item != nil {
				v.ShowProfileLimit = yyS[yypt-0].item.(*ast.Limit)
			}
			parser.yyVAL.statement = v
		}
	case 1288:
		{
			parser.yyVAL.statement = &ast.ShowStmt{
				Tp: ast.ShowPrivileges,
			}
		}
	case 1289:
		{
			stmt := &ast.ShowStmt{
				Tp: ast.ShowAnalyzeStatus,
			}
			if yyS[yypt-0].item != nil {
				if x, ok := yyS[yypt-0].item.(*ast.PatternLikeExpr); ok && x.Expr == nil {
					stmt.Pattern = x
				} else {
					stmt.Where = yyS[yypt-0].item.(ast.ExprNode)
				}
			}
			parser.yyVAL.statement = stmt
		}
	case 1290:
		{
			parser.yyVAL.item = nil
		}
	case 1291:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1292:
		{
			parser.yyVAL.item = []int{yyS[yypt-0].item.(int)}
		}
	case 1293:
		{
			l := yyS[yypt-2].item.([]int)
			l = append(l, yyS[yypt-0].item.(int))
			parser.yyVAL.item = l
		}
	case 1294:
		{
			parser.yyVAL.item = ast.ProfileTypeCPU
		}
	case 1295:
		{
			parser.yyVAL.item = ast.ProfileTypeMemory
		}
	case 1296:
		{
			parser.yyVAL.item = ast.ProfileTypeBlockIo
		}
	case 1297:
		{
			parser.yyVAL.item = ast.ProfileTypeContextSwitch
		}
	case 1298:
		{
			parser.yyVAL.item = ast.ProfileTypePageFaults
		}
	case 1299:
		{
			parser.yyVAL.item = ast.ProfileTypeIpc
		}
	case 1300:
		{
			parser.yyVAL.item = ast.ProfileTypeSwaps
		}
	case 1301:
		{
			parser.yyVAL.item = ast.ProfileTypeSource
		}
	case 1302:
		{
			parser.yyVAL.item = ast.ProfileTypeAll
		}
	case 1303:
		{
			parser.yyVAL.item = nil
		}
	case 1304:
		{
			v := yyS[yypt-0].item.(int64)
			parser.yyVAL.item = &v
		}
	case 1305:
		{
			parser.yyVAL.item = nil
		}
	case 1306:
		{
			parser.yyVAL.item = yyS[yypt-0].item.([]*auth.RoleIdentity)
		}
	case 1312:
		{
			parser.yyVAL.item = &ast.ShowStmt{Tp: ast.ShowEngines}
		}
	case 1313:
		{
			parser.yyVAL.item = &ast.ShowStmt{Tp: ast.ShowDatabases}
		}
	case 1314:
		{
			parser.yyVAL.item = &ast.ShowStmt{Tp: ast.ShowCharset}
		}
	case 1315:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowTables,
				DBName: yyS[yypt-0].item.(string),
				Full:   yyS[yypt-2].item.(bool),
			}
		}
	case 1316:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowOpenTables,
				DBName: yyS[yypt-0].item.(string),
			}
		}
	case 1317:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowTableStatus,
				DBName: yyS[yypt-0].item.(string),
			}
		}
	case 1318:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:    ast.ShowIndex,
				Table: yyS[yypt-0].item.(*ast.TableName),
			}
		}
	case 1319:
		{
			show := &ast.ShowStmt{
				Tp:    ast.ShowIndex,
				Table: &ast.TableName{Name: model.NewCIStr(yyS[yypt-2].ident), Schema: model.NewCIStr(yyS[yypt-0].ident)},
			}
			parser.yyVAL.item = show
		}
	case 1320:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowColumns,
				Table:  yyS[yypt-1].item.(*ast.TableName),
				DBName: yyS[yypt-0].item.(string),
				Full:   yyS[yypt-3].item.(bool),
			}
		}
	case 1321:
		{
			// SHOW FIELDS is a synonym for SHOW COLUMNS.
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowColumns,
				Table:  yyS[yypt-1].item.(*ast.TableName),
				DBName: yyS[yypt-0].item.(string),
				Full:   yyS[yypt-3].item.(bool),
			}
		}
	case 1322:
		{
			parser.yyVAL.item = &ast.ShowStmt{Tp: ast.ShowWarnings}
		}
	case 1323:
		{
			parser.yyVAL.item = &ast.ShowStmt{Tp: ast.ShowErrors}
		}
	case 1324:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:          ast.ShowVariables,
				GlobalScope: yyS[yypt-1].item.(bool),
			}
		}
	case 1325:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:          ast.ShowStatus,
				GlobalScope: yyS[yypt-1].item.(bool),
			}
		}
	case 1326:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:          ast.ShowBindings,
				GlobalScope: yyS[yypt-1].item.(bool),
			}
		}
	case 1327:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowCollation,
			}
		}
	case 1328:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowTriggers,
				DBName: yyS[yypt-0].item.(string),
			}
		}
	case 1329:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowProcedureStatus,
			}
		}
	case 1330:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowPumpStatus,
			}
		}
	case 1331:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowDrainerStatus,
			}
		}
	case 1332:
		{
			// This statement is similar to SHOW PROCEDURE STATUS but for stored functions.
			// See http://dev.mysql.com/doc/refman/5.7/en/show-function-status.html
			// We do not support neither stored functions nor stored procedures.
			// So we reuse show procedure status process logic.
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowProcedureStatus,
			}
		}
	case 1333:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp:     ast.ShowEvents,
				DBName: yyS[yypt-0].item.(string),
			}
		}
	case 1334:
		{
			parser.yyVAL.item = &ast.ShowStmt{
				Tp: ast.ShowPlugins,
			}
		}
	case 1335:
		{
			parser.yyVAL.item = nil
		}
	case 1336:
		{
			parser.yyVAL.item = &ast.PatternLikeExpr{
				Pattern: yyS[yypt-0].expr,
				Escape:  '\\',
			}
		}
	case 1337:
		{
			parser.yyVAL.item = yyS[yypt-0].expr
		}
	case 1338:
		{
			parser.yyVAL.item = false
		}
	case 1339:
		{
			parser.yyVAL.item = true
		}
	case 1340:
		{
			parser.yyVAL.item = false
		}
	case 1341:
		{
			parser.yyVAL.item = false
		}
	case 1342:
		{
			parser.yyVAL.item = true
		}
	case 1343:
		{
			parser.yyVAL.item = ""
		}
	case 1344:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(string)
		}
	case 1345:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(*ast.TableName)
		}
	case 1346:
		{
			tmp := yyS[yypt-0].item.(*ast.FlushStmt)
			tmp.NoWriteToBinLog = yyS[yypt-1].item.(bool)
			parser.yyVAL.statement = tmp
		}
	case 1347:
		{
			parser.yyVAL.item = []string{yyS[yypt-0].ident}
		}
	case 1348:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]string), yyS[yypt-0].ident)
		}
	case 1349:
		{
			parser.yyVAL.item = &ast.FlushStmt{
				Tp: ast.FlushPrivileges,
			}
		}
	case 1350:
		{
			parser.yyVAL.item = &ast.FlushStmt{
				Tp: ast.FlushStatus,
			}
		}
	case 1351:
		{
			parser.yyVAL.item = &ast.FlushStmt{
				Tp:      ast.FlushTiDBPlugin,
				Plugins: yyS[yypt-0].item.([]string),
			}
		}
	case 1352:
		{
			parser.yyVAL.item = &ast.FlushStmt{
				Tp:       ast.FlushTables,
				Tables:   yyS[yypt-1].item.([]*ast.TableName),
				ReadLock: yyS[yypt-0].item.(bool),
			}
		}
	case 1353:
		{
			parser.yyVAL.item = false
		}
	case 1354:
		{
			parser.yyVAL.item = true
		}
	case 1355:
		{
			parser.yyVAL.item = true
		}
	case 1356:
		{
			parser.yyVAL.item = []*ast.TableName{}
		}
	case 1357:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1358:
		{
			parser.yyVAL.item = false
		}
	case 1359:
		{
			parser.yyVAL.item = true
		}
	case 1411:
		{
			// `(select 1)`; is a valid select statement
			// TODO: This is used to fix issue #320. There may be a better solution.
			parser.yyVAL.statement = yyS[yypt-0].expr.(*ast.SubqueryExpr).Query.(ast.StmtNode)
		}
	case 1431:
		{
			if yyS[yypt-0].statement != nil {
				s := yyS[yypt-0].statement
				if lexer, ok := yylex.(stmtTexter); ok {
					s.SetText(lexer.stmtText())
				}
				parser.result = append(parser.result, s)
			}
		}
	case 1432:
		{
			if yyS[yypt-0].statement != nil {
				s := yyS[yypt-0].statement
				if lexer, ok := yylex.(stmtTexter); ok {
					s.SetText(lexer.stmtText())
				}
				parser.result = append(parser.result, s)
			}
		}
	case 1433:
		{
			cst := yyS[yypt-0].item.(*ast.Constraint)
			if yyS[yypt-1].item != nil {
				cst.Name = yyS[yypt-1].item.(string)
			}
			parser.yyVAL.item = cst
		}
	case 1434:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(*ast.ColumnDef)
		}
	case 1435:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(*ast.Constraint)
		}
	case 1436:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.item = []interface{}{yyS[yypt-0].item.(interface{})}
			} else {
				parser.yyVAL.item = []interface{}{}
			}
		}
	case 1437:
		{
			if yyS[yypt-0].item != nil {
				parser.yyVAL.item = append(yyS[yypt-2].item.([]interface{}), yyS[yypt-0].item)
			} else {
				parser.yyVAL.item = yyS[yypt-2].item
			}
		}
	case 1438:
		{
			var columnDefs []*ast.ColumnDef
			var constraints []*ast.Constraint
			parser.yyVAL.item = &ast.CreateTableStmt{
				Cols:        columnDefs,
				Constraints: constraints,
			}
		}
	case 1439:
		{
			tes := yyS[yypt-1].item.([]interface{})
			var columnDefs []*ast.ColumnDef
			var constraints []*ast.Constraint
			for _, te := range tes {
				switch te := te.(type) {
				case *ast.ColumnDef:
					columnDefs = append(columnDefs, te)
				case *ast.Constraint:
					constraints = append(constraints, te)
				}
			}
			parser.yyVAL.item = &ast.CreateTableStmt{
				Cols:        columnDefs,
				Constraints: constraints,
			}
		}
	case 1440:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1441:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionCharset, StrValue: yyS[yypt-0].item.(string)}
		}
	case 1442:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionCollate, StrValue: yyS[yypt-0].item.(string)}
		}
	case 1443:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionAutoIncrement, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1444:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionAvgRowLength, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1445:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionConnection, StrValue: yyS[yypt-0].ident}
		}
	case 1446:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionCheckSum, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1447:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionPassword, StrValue: yyS[yypt-0].ident}
		}
	case 1448:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionCompression, StrValue: yyS[yypt-0].ident}
		}
	case 1449:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionKeyBlockSize, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1450:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionDelayKeyWrite, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1451:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionRowFormat, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1452:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionStatsPersistent}
		}
	case 1453:
		{
			// Parse it but will ignore it.
			// In MySQL, STATS_SAMPLE_PAGES=N(Where 0<N<=65535) or STAS_SAMPLE_PAGES=DEFAULT.
			// Cause we don't support it, so we don't check range of the value.
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionStatsSamplePages, UintValue: yyS[yypt-0].item.(uint64)}
			yylex.AppendError(yylex.Errorf("The STATS_SAMPLE_PAGES is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1454:
		{
			// Parse it but will ignore it.
			// In MySQL, default value of STATS_SAMPLE_PAGES is 0.
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionStatsSamplePages, UintValue: 0}
			yylex.AppendError(yylex.Errorf("The STATS_SAMPLE_PAGES is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1455:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionShardRowID, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1456:
		{
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionPreSplitRegion, UintValue: yyS[yypt-0].item.(uint64)}
		}
	case 1457:
		{
			// Parse it but will ignore it.
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionPackKeys}
		}
	case 1458:
		{
			// Parse it but will ignore it.
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionStorageMedia, StrValue: "MEMORY"}
			yylex.AppendError(yylex.Errorf("The STORAGE clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1459:
		{
			// Parse it but will ignore it.
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionStorageMedia, StrValue: "DISK"}
			yylex.AppendError(yylex.Errorf("The STORAGE clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1460:
		{
			// Parse it but will ignore it
			// See https://github.com/mysql/mysql-server/blob/8.0/sql/sql_yacc.yy#L5977-L5984
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionSecondaryEngineNull}
			yylex.AppendError(yylex.Errorf("The SECONDARY_ENGINE clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1461:
		{
			// Parse it but will ignore it
			// See https://github.com/mysql/mysql-server/blob/8.0/sql/sql_yacc.yy#L5977-L5984
			parser.yyVAL.item = &ast.TableOption{Tp: ast.TableOptionSecondaryEngine, StrValue: yyS[yypt-0].item.(string)}
			yylex.AppendError(yylex.Errorf("The SECONDARY_ENGINE clause is parsed but ignored by all storage engines."))
			parser.lastErrorAsWarn()
		}
	case 1464:
		{
			parser.yyVAL.item = []*ast.TableOption{}
		}
	case 1466:
		{
			parser.yyVAL.item = []*ast.TableOption{yyS[yypt-0].item.(*ast.TableOption)}
		}
	case 1467:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.TableOption), yyS[yypt-0].item.(*ast.TableOption))
		}
	case 1468:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.TableOption), yyS[yypt-0].item.(*ast.TableOption))
		}
	case 1471:
		{
			parser.yyVAL.statement = &ast.TruncateTableStmt{Table: yyS[yypt-0].item.(*ast.TableName)}
		}
	case 1472:
		{
			parser.yyVAL.item = ast.RowFormatDefault
		}
	case 1473:
		{
			parser.yyVAL.item = ast.RowFormatDynamic
		}
	case 1474:
		{
			parser.yyVAL.item = ast.RowFormatFixed
		}
	case 1475:
		{
			parser.yyVAL.item = ast.RowFormatCompressed
		}
	case 1476:
		{
			parser.yyVAL.item = ast.RowFormatRedundant
		}
	case 1477:
		{
			parser.yyVAL.item = ast.RowFormatCompact
		}
	case 1478:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatDefault
		}
	case 1479:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatFast
		}
	case 1480:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatSmall
		}
	case 1481:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatZlib
		}
	case 1482:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatQuickLZ
		}
	case 1483:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatLzma
		}
	case 1484:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatSnappy
		}
	case 1485:
		{
			parser.yyVAL.item = ast.TokuDBRowFormatUncompressed
		}
	case 1486:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1487:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1488:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1489:
		{
			// TODO: check flen 0
			x := types.NewFieldType(yyS[yypt-2].item.(byte))
			x.Flen = yyS[yypt-1].item.(int)
			for _, o := range yyS[yypt-0].item.([]*ast.TypeOpt) {
				if o.IsUnsigned {
					x.Flag |= mysql.UnsignedFlag
				}
				if o.IsZerofill {
					x.Flag |= mysql.ZerofillFlag
				}
			}
			parser.yyVAL.item = x
		}
	case 1490:
		{
			// TODO: check flen 0
			x := types.NewFieldType(yyS[yypt-1].item.(byte))
			x.Flen = 1
			for _, o := range yyS[yypt-0].item.([]*ast.TypeOpt) {
				if o.IsUnsigned {
					x.Flag |= mysql.UnsignedFlag
				}
				if o.IsZerofill {
					x.Flag |= mysql.ZerofillFlag
				}
			}
			parser.yyVAL.item = x
		}
	case 1491:
		{
			fopt := yyS[yypt-1].item.(*ast.FloatOpt)
			x := types.NewFieldType(yyS[yypt-2].item.(byte))
			x.Flen = fopt.Flen
			x.Decimal = fopt.Decimal
			for _, o := range yyS[yypt-0].item.([]*ast.TypeOpt) {
				if o.IsUnsigned {
					x.Flag |= mysql.UnsignedFlag
				}
				if o.IsZerofill {
					x.Flag |= mysql.ZerofillFlag
				}
			}
			parser.yyVAL.item = x
		}
	case 1492:
		{
			fopt := yyS[yypt-1].item.(*ast.FloatOpt)
			x := types.NewFieldType(yyS[yypt-2].item.(byte))
			x.Flen = fopt.Flen
			if x.Tp == mysql.TypeFloat && fopt.Decimal == types.UnspecifiedLength && x.Flen <= 53 {
				if x.Flen > 24 {
					x.Tp = mysql.TypeDouble
				}
				x.Flen = types.UnspecifiedLength
			}
			x.Decimal = fopt.Decimal
			for _, o := range yyS[yypt-0].item.([]*ast.TypeOpt) {
				if o.IsUnsigned {
					x.Flag |= mysql.UnsignedFlag
				}
				if o.IsZerofill {
					x.Flag |= mysql.ZerofillFlag
				}
			}
			parser.yyVAL.item = x
		}
	case 1493:
		{
			x := types.NewFieldType(yyS[yypt-1].item.(byte))
			x.Flen = yyS[yypt-0].item.(int)
			if x.Flen == types.UnspecifiedLength || x.Flen == 0 {
				x.Flen = 1
			} else if x.Flen > 64 {
				yylex.AppendError(ErrTooBigDisplayWidth.GenWithStackByArgs(x.Flen))
			}
			parser.yyVAL.item = x
		}
	case 1494:
		{
			parser.yyVAL.item = mysql.TypeTiny
		}
	case 1495:
		{
			parser.yyVAL.item = mysql.TypeShort
		}
	case 1496:
		{
			parser.yyVAL.item = mysql.TypeInt24
		}
	case 1497:
		{
			parser.yyVAL.item = mysql.TypeLong
		}
	case 1498:
		{
			parser.yyVAL.item = mysql.TypeTiny
		}
	case 1499:
		{
			parser.yyVAL.item = mysql.TypeShort
		}
	case 1500:
		{
			parser.yyVAL.item = mysql.TypeInt24
		}
	case 1501:
		{
			parser.yyVAL.item = mysql.TypeLong
		}
	case 1502:
		{
			parser.yyVAL.item = mysql.TypeLonglong
		}
	case 1503:
		{
			parser.yyVAL.item = mysql.TypeLong
		}
	case 1504:
		{
			parser.yyVAL.item = mysql.TypeLonglong
		}
	case 1505:
		{
			parser.yyVAL.item = mysql.TypeTiny
		}
	case 1506:
		{
			parser.yyVAL.item = mysql.TypeTiny
		}
	case 1510:
		{
			parser.yyVAL.item = mysql.TypeNewDecimal
		}
	case 1511:
		{
			parser.yyVAL.item = mysql.TypeNewDecimal
		}
	case 1512:
		{
			parser.yyVAL.item = mysql.TypeFloat
		}
	case 1513:
		{
			if parser.lexer.GetSQLMode().HasRealAsFloatMode() {
				parser.yyVAL.item = mysql.TypeFloat
			} else {
				parser.yyVAL.item = mysql.TypeDouble
			}
		}
	case 1514:
		{
			parser.yyVAL.item = mysql.TypeDouble
		}
	case 1515:
		{
			parser.yyVAL.item = mysql.TypeDouble
		}
	case 1516:
		{
			parser.yyVAL.item = mysql.TypeBit
		}
	case 1517:
		{
			x := types.NewFieldType(mysql.TypeString)
			x.Flen = yyS[yypt-1].item.(int)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1518:
		{
			x := types.NewFieldType(mysql.TypeString)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1519:
		{
			x := types.NewFieldType(mysql.TypeString)
			x.Flen = yyS[yypt-1].item.(int)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1520:
		{
			x := types.NewFieldType(mysql.TypeString)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1521:
		{
			x := types.NewFieldType(mysql.TypeVarchar)
			x.Flen = yyS[yypt-1].item.(int)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1522:
		{
			x := types.NewFieldType(mysql.TypeVarchar)
			x.Flen = yyS[yypt-1].item.(int)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1523:
		{
			x := types.NewFieldType(mysql.TypeString)
			x.Flen = yyS[yypt-0].item.(int)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CharsetBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 1524:
		{
			x := types.NewFieldType(mysql.TypeVarchar)
			x.Flen = yyS[yypt-0].item.(int)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CharsetBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = x
		}
	case 1525:
		{
			x := yyS[yypt-0].item.(*types.FieldType)
			x.Charset = charset.CharsetBin
			x.Collate = charset.CharsetBin
			x.Flag |= mysql.BinaryFlag
			parser.yyVAL.item = yyS[yypt-0].item.(*types.FieldType)
		}
	case 1526:
		{
			x := yyS[yypt-1].item.(*types.FieldType)
			x.Charset = yyS[yypt-0].item.(*ast.OptBinary).Charset
			if yyS[yypt-0].item.(*ast.OptBinary).IsBinary {
				x.Flag |= mysql.BinaryFlag
			}
			parser.yyVAL.item = x
		}
	case 1527:
		{
			x := types.NewFieldType(mysql.TypeEnum)
			x.Elems = yyS[yypt-2].item.([]string)
			x.Charset = yyS[yypt-0].item.(string)
			parser.yyVAL.item = x
		}
	case 1528:
		{
			x := types.NewFieldType(mysql.TypeSet)
			x.Elems = yyS[yypt-2].item.([]string)
			x.Charset = yyS[yypt-0].item.(string)
			parser.yyVAL.item = x
		}
	case 1529:
		{
			x := types.NewFieldType(mysql.TypeJSON)
			x.Decimal = 0
			x.Charset = charset.CharsetBin
			x.Collate = charset.CollationBin
			parser.yyVAL.item = x
		}
	case 1544:
		{
			x := types.NewFieldType(mysql.TypeTinyBlob)
			parser.yyVAL.item = x
		}
	case 1545:
		{
			x := types.NewFieldType(mysql.TypeBlob)
			x.Flen = yyS[yypt-0].item.(int)
			parser.yyVAL.item = x
		}
	case 1546:
		{
			x := types.NewFieldType(mysql.TypeMediumBlob)
			parser.yyVAL.item = x
		}
	case 1547:
		{
			x := types.NewFieldType(mysql.TypeLongBlob)
			parser.yyVAL.item = x
		}
	case 1548:
		{
			x := types.NewFieldType(mysql.TypeTinyBlob)
			parser.yyVAL.item = x

		}
	case 1549:
		{
			x := types.NewFieldType(mysql.TypeBlob)
			x.Flen = yyS[yypt-0].item.(int)
			parser.yyVAL.item = x
		}
	case 1550:
		{
			x := types.NewFieldType(mysql.TypeMediumBlob)
			parser.yyVAL.item = x
		}
	case 1551:
		{
			x := types.NewFieldType(mysql.TypeLongBlob)
			parser.yyVAL.item = x
		}
	case 1552:
		{
			x := types.NewFieldType(mysql.TypeMediumBlob)
			parser.yyVAL.item = x
		}
	case 1553:
		{
			x := types.NewFieldType(mysql.TypeDate)
			parser.yyVAL.item = x
		}
	case 1554:
		{
			x := types.NewFieldType(mysql.TypeDatetime)
			x.Flen = mysql.MaxDatetimeWidthNoFsp
			x.Decimal = yyS[yypt-0].item.(int)
			if x.Decimal > 0 {
				x.Flen = x.Flen + 1 + x.Decimal
			}
			parser.yyVAL.item = x
		}
	case 1555:
		{
			x := types.NewFieldType(mysql.TypeTimestamp)
			x.Flen = mysql.MaxDatetimeWidthNoFsp
			x.Decimal = yyS[yypt-0].item.(int)
			if x.Decimal > 0 {
				x.Flen = x.Flen + 1 + x.Decimal
			}
			parser.yyVAL.item = x
		}
	case 1556:
		{
			x := types.NewFieldType(mysql.TypeDuration)
			x.Flen = mysql.MaxDurationWidthNoFsp
			x.Decimal = yyS[yypt-0].item.(int)
			if x.Decimal > 0 {
				x.Flen = x.Flen + 1 + x.Decimal
			}
			parser.yyVAL.item = x
		}
	case 1557:
		{
			x := types.NewFieldType(mysql.TypeYear)
			x.Flen = yyS[yypt-1].item.(int)
			if x.Flen != types.UnspecifiedLength && x.Flen != 4 {
				yylex.AppendError(ErrInvalidYearColumnLength.GenWithStackByArgs())
				return -1
			}
			parser.yyVAL.item = x
		}
	case 1558:
		{
			parser.yyVAL.item = int(yyS[yypt-1].item.(uint64))
		}
	case 1559:
		{
			parser.yyVAL.item = types.UnspecifiedLength
		}
	case 1560:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(int)
		}
	case 1561:
		{
			parser.yyVAL.item = &ast.TypeOpt{IsUnsigned: true}
		}
	case 1562:
		{
			parser.yyVAL.item = &ast.TypeOpt{IsUnsigned: false}
		}
	case 1563:
		{
			parser.yyVAL.item = &ast.TypeOpt{IsZerofill: true, IsUnsigned: true}
		}
	case 1564:
		{
			parser.yyVAL.item = []*ast.TypeOpt{}
		}
	case 1565:
		{
			parser.yyVAL.item = append(yyS[yypt-1].item.([]*ast.TypeOpt), yyS[yypt-0].item.(*ast.TypeOpt))
		}
	case 1566:
		{
			parser.yyVAL.item = &ast.FloatOpt{Flen: types.UnspecifiedLength, Decimal: types.UnspecifiedLength}
		}
	case 1567:
		{
			parser.yyVAL.item = &ast.FloatOpt{Flen: yyS[yypt-0].item.(int), Decimal: types.UnspecifiedLength}
		}
	case 1568:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(*ast.FloatOpt)
		}
	case 1569:
		{
			parser.yyVAL.item = &ast.FloatOpt{Flen: int(yyS[yypt-3].item.(uint64)), Decimal: int(yyS[yypt-1].item.(uint64))}
		}
	case 1570:
		{
			parser.yyVAL.item = false
		}
	case 1571:
		{
			parser.yyVAL.item = true
		}
	case 1572:
		{
			parser.yyVAL.item = &ast.OptBinary{
				IsBinary: false,
				Charset:  "",
			}
		}
	case 1573:
		{
			parser.yyVAL.item = &ast.OptBinary{
				IsBinary: true,
				Charset:  yyS[yypt-0].item.(string),
			}
		}
	case 1574:
		{
			parser.yyVAL.item = &ast.OptBinary{
				IsBinary: yyS[yypt-0].item.(bool),
				Charset:  yyS[yypt-1].item.(string),
			}
		}
	case 1575:
		{
			parser.yyVAL.item = ""
		}
	case 1576:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(string)
		}
	case 1580:
		{
			parser.yyVAL.item = ""
		}
	case 1581:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(string)
		}
	case 1582:
		{
			parser.yyVAL.item = []string{yyS[yypt-0].ident}
		}
	case 1583:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]string), yyS[yypt-0].ident)
		}
	case 1584:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1585:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1586:
		{
			var refs *ast.Join
			if x, ok := yyS[yypt-5].item.(*ast.Join); ok {
				refs = x
			} else {
				refs = &ast.Join{Left: yyS[yypt-5].item.(ast.ResultSetNode)}
			}
			st := &ast.UpdateStmt{
				Priority:  yyS[yypt-7].item.(mysql.PriorityEnum),
				TableRefs: &ast.TableRefsClause{TableRefs: refs},
				List:      yyS[yypt-3].item.([]*ast.Assignment),
				IgnoreErr: yyS[yypt-6].item.(bool),
			}
			if yyS[yypt-8].item != nil {
				st.TableHints = yyS[yypt-8].item.([]*ast.TableOptimizerHint)
			}
			if yyS[yypt-2].item != nil {
				st.Where = yyS[yypt-2].item.(ast.ExprNode)
			}
			if yyS[yypt-1].item != nil {
				st.Order = yyS[yypt-1].item.(*ast.OrderByClause)
			}
			if yyS[yypt-0].item != nil {
				st.Limit = yyS[yypt-0].item.(*ast.Limit)
			}
			parser.yyVAL.statement = st
		}
	case 1587:
		{
			st := &ast.UpdateStmt{
				Priority:  yyS[yypt-5].item.(mysql.PriorityEnum),
				TableRefs: &ast.TableRefsClause{TableRefs: yyS[yypt-3].item.(*ast.Join)},
				List:      yyS[yypt-1].item.([]*ast.Assignment),
				IgnoreErr: yyS[yypt-4].item.(bool),
			}
			if yyS[yypt-6].item != nil {
				st.TableHints = yyS[yypt-6].item.([]*ast.TableOptimizerHint)
			}
			if yyS[yypt-0].item != nil {
				st.Where = yyS[yypt-0].item.(ast.ExprNode)
			}
			parser.yyVAL.statement = st
		}
	case 1588:
		{
			parser.yyVAL.statement = &ast.UseStmt{DBName: yyS[yypt-0].item.(string)}
		}
	case 1589:
		{
			parser.yyVAL.item = yyS[yypt-0].expr
		}
	case 1590:
		{
			parser.yyVAL.item = nil
		}
	case 1591:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1594:
		{
			// See https://dev.mysql.com/doc/refman/5.7/en/create-user.html
			parser.yyVAL.statement = &ast.CreateUserStmt{
				IsCreateRole:          false,
				IfNotExists:           yyS[yypt-4].item.(bool),
				Specs:                 yyS[yypt-3].item.([]*ast.UserSpec),
				TslOptions:            yyS[yypt-2].item.([]*ast.TslOption),
				ResourceOptions:       yyS[yypt-1].item.([]*ast.ResourceOption),
				PasswordOrLockOptions: yyS[yypt-0].item.([]*ast.PasswordOrLockOption),
			}
		}
	case 1595:
		{
			// See https://dev.mysql.com/doc/refman/8.0/en/create-role.html
			parser.yyVAL.statement = &ast.CreateUserStmt{
				IsCreateRole: true,
				IfNotExists:  yyS[yypt-1].item.(bool),
				Specs:        yyS[yypt-0].item.([]*ast.UserSpec),
			}
		}
	case 1596:
		{
			parser.yyVAL.statement = &ast.AlterUserStmt{
				IfExists:              yyS[yypt-4].item.(bool),
				Specs:                 yyS[yypt-3].item.([]*ast.UserSpec),
				TslOptions:            yyS[yypt-2].item.([]*ast.TslOption),
				ResourceOptions:       yyS[yypt-1].item.([]*ast.ResourceOption),
				PasswordOrLockOptions: yyS[yypt-0].item.([]*ast.PasswordOrLockOption),
			}
		}
	case 1597:
		{
			auth := &ast.AuthOption{
				AuthString:   yyS[yypt-0].item.(string),
				ByAuthString: true,
			}
			parser.yyVAL.statement = &ast.AlterUserStmt{
				IfExists:    yyS[yypt-6].item.(bool),
				CurrentAuth: auth,
			}
		}
	case 1598:
		{
			userSpec := &ast.UserSpec{
				User: yyS[yypt-1].item.(*auth.UserIdentity),
			}
			if yyS[yypt-0].item != nil {
				userSpec.AuthOpt = yyS[yypt-0].item.(*ast.AuthOption)
			}
			parser.yyVAL.item = userSpec
		}
	case 1599:
		{
			parser.yyVAL.item = []*ast.UserSpec{yyS[yypt-0].item.(*ast.UserSpec)}
		}
	case 1600:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.UserSpec), yyS[yypt-0].item.(*ast.UserSpec))
		}
	case 1601:
		{
			l := []*ast.ResourceOption{}
			parser.yyVAL.item = l
		}
	case 1602:
		{
			parser.yyVAL.item = yyS[yypt-0].item
			yylex.AppendError(yylex.Errorf("TiDB does not support WITH ConnectionOptions now, they would be parsed but ignored."))
			parser.lastErrorAsWarn()
		}
	case 1603:
		{
			parser.yyVAL.item = []*ast.ResourceOption{yyS[yypt-0].item.(*ast.ResourceOption)}
		}
	case 1604:
		{
			l := yyS[yypt-1].item.([]*ast.ResourceOption)
			l = append(l, yyS[yypt-0].item.(*ast.ResourceOption))
			parser.yyVAL.item = l
		}
	case 1605:
		{
			parser.yyVAL.item = &ast.ResourceOption{
				Type:  ast.MaxQueriesPerHour,
				Count: yyS[yypt-0].item.(int64),
			}
		}
	case 1606:
		{
			parser.yyVAL.item = &ast.ResourceOption{
				Type:  ast.MaxUpdatesPerHour,
				Count: yyS[yypt-0].item.(int64),
			}
		}
	case 1607:
		{
			parser.yyVAL.item = &ast.ResourceOption{
				Type:  ast.MaxConnectionsPerHour,
				Count: yyS[yypt-0].item.(int64),
			}
		}
	case 1608:
		{
			parser.yyVAL.item = &ast.ResourceOption{
				Type:  ast.MaxUserConnections,
				Count: yyS[yypt-0].item.(int64),
			}
		}
	case 1609:
		{
			parser.yyVAL.item = []*ast.TslOption{}
		}
	case 1610:
		{
			parser.yyVAL.item = yyS[yypt-0].item
			yylex.AppendError(yylex.Errorf("TiDB does not support REQUIRE now, they would be parsed but ignored."))
			parser.lastErrorAsWarn()
		}
	case 1611:
		{
			t := &ast.TslOption{
				Type: ast.TslNone,
			}
			parser.yyVAL.item = []*ast.TslOption{t}
		}
	case 1612:
		{
			t := &ast.TslOption{
				Type: ast.Ssl,
			}
			parser.yyVAL.item = []*ast.TslOption{t}
		}
	case 1613:
		{
			t := &ast.TslOption{
				Type: ast.X509,
			}
			parser.yyVAL.item = []*ast.TslOption{t}
		}
	case 1614:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1615:
		{
			parser.yyVAL.item = []*ast.TslOption{yyS[yypt-0].item.(*ast.TslOption)}
		}
	case 1616:
		{
			l := yyS[yypt-0].item.([]*ast.TslOption)
			l = append(l, yyS[yypt-2].item.(*ast.TslOption))
			parser.yyVAL.item = l
		}
	case 1617:
		{
			parser.yyVAL.item = &ast.TslOption{
				Type:  ast.Issuer,
				Value: yyS[yypt-0].ident,
			}
		}
	case 1618:
		{
			parser.yyVAL.item = &ast.TslOption{
				Type:  ast.Subject,
				Value: yyS[yypt-0].ident,
			}
		}
	case 1619:
		{
			parser.yyVAL.item = &ast.TslOption{
				Type:  ast.Cipher,
				Value: yyS[yypt-0].ident,
			}
		}
	case 1620:
		{
			l := []*ast.PasswordOrLockOption{}
			parser.yyVAL.item = l
		}
	case 1621:
		{
			parser.yyVAL.item = yyS[yypt-0].item
			yylex.AppendError(yylex.Errorf("TiDB does not support PASSWORD EXPIRE and ACCOUNT LOCK now, they would be parsed but ignored."))
			parser.lastErrorAsWarn()
		}
	case 1622:
		{
			parser.yyVAL.item = []*ast.PasswordOrLockOption{yyS[yypt-0].item.(*ast.PasswordOrLockOption)}
		}
	case 1623:
		{
			l := yyS[yypt-1].item.([]*ast.PasswordOrLockOption)
			l = append(l, yyS[yypt-0].item.(*ast.PasswordOrLockOption))
			parser.yyVAL.item = l
		}
	case 1624:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type: ast.Unlock,
			}
		}
	case 1625:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type: ast.Lock,
			}
		}
	case 1626:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type: ast.PasswordExpire,
			}
		}
	case 1627:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type:  ast.PasswordExpireInterval,
				Count: yyS[yypt-1].item.(int64),
			}
		}
	case 1628:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type: ast.PasswordExpireNever,
			}
		}
	case 1629:
		{
			parser.yyVAL.item = &ast.PasswordOrLockOption{
				Type: ast.PasswordExpireDefault,
			}
		}
	case 1630:
		{
			parser.yyVAL.item = nil
		}
	case 1631:
		{
			parser.yyVAL.item = nil
		}
	case 1632:
		{
			parser.yyVAL.item = nil
		}
	case 1633:
		{
			parser.yyVAL.item = &ast.AuthOption{
				AuthString:   yyS[yypt-0].item.(string),
				ByAuthString: true,
			}
		}
	case 1634:
		{
			parser.yyVAL.item = nil
		}
	case 1635:
		{
			parser.yyVAL.item = &ast.AuthOption{
				AuthString:   yyS[yypt-0].item.(string),
				ByAuthString: true,
			}
		}
	case 1636:
		{
			parser.yyVAL.item = &ast.AuthOption{
				HashString: yyS[yypt-0].item.(string),
			}
		}
	case 1637:
		{
			parser.yyVAL.item = &ast.AuthOption{
				HashString: yyS[yypt-0].item.(string),
			}
		}
	case 1638:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1639:
		{
			role := yyS[yypt-0].item.(*auth.RoleIdentity)
			roleSpec := &ast.UserSpec{
				User: &auth.UserIdentity{
					Username: role.Username,
					Hostname: role.Hostname,
				},
				IsRole: true,
			}
			parser.yyVAL.item = roleSpec
		}
	case 1640:
		{
			parser.yyVAL.item = []*ast.UserSpec{yyS[yypt-0].item.(*ast.UserSpec)}
		}
	case 1641:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.UserSpec), yyS[yypt-0].item.(*ast.UserSpec))
		}
	case 1642:
		{
			startOffset := parser.startOffset(&yyS[yypt-2])
			endOffset := parser.startOffset(&yyS[yypt-1])
			selStmt := yyS[yypt-2].statement.(*ast.SelectStmt)
			selStmt.SetText(strings.TrimSpace(parser.src[startOffset:endOffset]))

			startOffset = parser.startOffset(&yyS[yypt])
			hintedSelStmt := yyS[yypt-0].statement.(*ast.SelectStmt)
			hintedSelStmt.SetText(strings.TrimSpace(parser.src[startOffset:]))

			x := &ast.CreateBindingStmt{
				OriginSel:   selStmt,
				HintedSel:   hintedSelStmt,
				GlobalScope: yyS[yypt-5].item.(bool),
			}

			parser.yyVAL.statement = x
		}
	case 1643:
		{
			startOffset := parser.startOffset(&yyS[yypt])
			selStmt := yyS[yypt-0].statement.(*ast.SelectStmt)
			selStmt.SetText(strings.TrimSpace(parser.src[startOffset:]))

			x := &ast.DropBindingStmt{
				OriginSel:   selStmt,
				GlobalScope: yyS[yypt-3].item.(bool),
			}

			parser.yyVAL.statement = x
		}
	case 1644:
		{
			parser.yyVAL.statement = &ast.GrantStmt{
				Privs:      yyS[yypt-6].item.([]*ast.PrivElem),
				ObjectType: yyS[yypt-4].item.(ast.ObjectTypeType),
				Level:      yyS[yypt-3].item.(*ast.GrantLevel),
				Users:      yyS[yypt-1].item.([]*ast.UserSpec),
				WithGrant:  yyS[yypt-0].item.(bool),
			}
		}
	case 1645:
		{
			parser.yyVAL.statement = &ast.GrantRoleStmt{
				Roles: yyS[yypt-2].item.([]*auth.RoleIdentity),
				Users: yyS[yypt-0].item.([]*auth.UserIdentity),
			}
		}
	case 1646:
		{
			parser.yyVAL.item = false
		}
	case 1647:
		{
			parser.yyVAL.item = true
		}
	case 1648:
		{
			parser.yyVAL.item = false
		}
	case 1649:
		{
			parser.yyVAL.item = false
		}
	case 1650:
		{
			parser.yyVAL.item = false
		}
	case 1651:
		{
			parser.yyVAL.item = false
		}
	case 1652:
		{
			parser.yyVAL.item = &ast.PrivElem{
				Priv: yyS[yypt-0].item.(mysql.PrivilegeType),
			}
		}
	case 1653:
		{
			parser.yyVAL.item = &ast.PrivElem{
				Priv: yyS[yypt-3].item.(mysql.PrivilegeType),
				Cols: yyS[yypt-1].item.([]*ast.ColumnName),
			}
		}
	case 1654:
		{
			parser.yyVAL.item = []*ast.PrivElem{yyS[yypt-0].item.(*ast.PrivElem)}
		}
	case 1655:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]*ast.PrivElem), yyS[yypt-0].item.(*ast.PrivElem))
		}
	case 1656:
		{
			parser.yyVAL.item = mysql.AllPriv
		}
	case 1657:
		{
			parser.yyVAL.item = mysql.AllPriv
		}
	case 1658:
		{
			parser.yyVAL.item = mysql.AlterPriv
		}
	case 1659:
		{
			parser.yyVAL.item = mysql.CreatePriv
		}
	case 1660:
		{
			parser.yyVAL.item = mysql.CreateUserPriv
		}
	case 1661:
		{
			parser.yyVAL.item = mysql.TriggerPriv
		}
	case 1662:
		{
			parser.yyVAL.item = mysql.DeletePriv
		}
	case 1663:
		{
			parser.yyVAL.item = mysql.DropPriv
		}
	case 1664:
		{
			parser.yyVAL.item = mysql.ProcessPriv
		}
	case 1665:
		{
			parser.yyVAL.item = mysql.ExecutePriv
		}
	case 1666:
		{
			parser.yyVAL.item = mysql.IndexPriv
		}
	case 1667:
		{
			parser.yyVAL.item = mysql.InsertPriv
		}
	case 1668:
		{
			parser.yyVAL.item = mysql.SelectPriv
		}
	case 1669:
		{
			parser.yyVAL.item = mysql.SuperPriv
		}
	case 1670:
		{
			parser.yyVAL.item = mysql.ShowDBPriv
		}
	case 1671:
		{
			parser.yyVAL.item = mysql.UpdatePriv
		}
	case 1672:
		{
			parser.yyVAL.item = mysql.GrantPriv
		}
	case 1673:
		{
			parser.yyVAL.item = mysql.ReferencesPriv
		}
	case 1674:
		{
			parser.yyVAL.item = mysql.PrivilegeType(0)
		}
	case 1675:
		{
			parser.yyVAL.item = mysql.PrivilegeType(0)
		}
	case 1676:
		{
			parser.yyVAL.item = mysql.PrivilegeType(0)
		}
	case 1677:
		{
			parser.yyVAL.item = mysql.PrivilegeType(0)
		}
	case 1678:
		{
			parser.yyVAL.item = mysql.CreateTMPTablePriv
		}
	case 1679:
		{
			parser.yyVAL.item = mysql.LockTablesPriv
		}
	case 1680:
		{
			parser.yyVAL.item = mysql.CreateViewPriv
		}
	case 1681:
		{
			parser.yyVAL.item = mysql.ShowViewPriv
		}
	case 1682:
		{
			parser.yyVAL.item = mysql.CreateRolePriv
		}
	case 1683:
		{
			parser.yyVAL.item = mysql.DropRolePriv
		}
	case 1684:
		{
			parser.yyVAL.item = mysql.CreateRoutinePriv
		}
	case 1685:
		{
			parser.yyVAL.item = mysql.AlterRoutinePriv
		}
	case 1686:
		{
			parser.yyVAL.item = mysql.EventPriv
		}
	case 1687:
		{
			parser.yyVAL.item = ast.ObjectTypeNone
		}
	case 1688:
		{
			parser.yyVAL.item = ast.ObjectTypeTable
		}
	case 1689:
		{
			parser.yyVAL.item = &ast.GrantLevel{
				Level: ast.GrantLevelDB,
			}
		}
	case 1690:
		{
			parser.yyVAL.item = &ast.GrantLevel{
				Level: ast.GrantLevelGlobal,
			}
		}
	case 1691:
		{
			parser.yyVAL.item = &ast.GrantLevel{
				Level:  ast.GrantLevelDB,
				DBName: yyS[yypt-2].ident,
			}
		}
	case 1692:
		{
			parser.yyVAL.item = &ast.GrantLevel{
				Level:     ast.GrantLevelTable,
				DBName:    yyS[yypt-2].ident,
				TableName: yyS[yypt-0].ident,
			}
		}
	case 1693:
		{
			parser.yyVAL.item = &ast.GrantLevel{
				Level:     ast.GrantLevelTable,
				TableName: yyS[yypt-0].ident,
			}
		}
	case 1694:
		{
			parser.yyVAL.statement = &ast.RevokeStmt{
				Privs:      yyS[yypt-5].item.([]*ast.PrivElem),
				ObjectType: yyS[yypt-3].item.(ast.ObjectTypeType),
				Level:      yyS[yypt-2].item.(*ast.GrantLevel),
				Users:      yyS[yypt-0].item.([]*ast.UserSpec),
			}
		}
	case 1695:
		{
			parser.yyVAL.statement = &ast.RevokeRoleStmt{
				Roles: yyS[yypt-2].item.([]*auth.RoleIdentity),
				Users: yyS[yypt-0].item.([]*auth.UserIdentity),
			}
		}
	case 1696:
		{
			x := &ast.LoadDataStmt{
				Path:               yyS[yypt-10].ident,
				OnDuplicate:        yyS[yypt-9].item.(ast.OnDuplicateKeyHandlingType),
				Table:              yyS[yypt-6].item.(*ast.TableName),
				ColumnsAndUserVars: yyS[yypt-1].item.([]*ast.ColumnNameOrUserVar),
				IgnoreLines:        yyS[yypt-2].item.(uint64),
			}
			if yyS[yypt-12].item != nil {
				x.IsLocal = true
				// See https://dev.mysql.com/doc/refman/5.7/en/load-data.html#load-data-duplicate-key-handling
				// If you do not specify IGNORE or REPLACE modifier , then we set default behavior to IGNORE when LOCAL modifier is specified
				if x.OnDuplicate == ast.OnDuplicateKeyHandlingError {
					x.OnDuplicate = ast.OnDuplicateKeyHandlingIgnore
				}
			}
			if yyS[yypt-4].item != nil {
				x.FieldsInfo = yyS[yypt-4].item.(*ast.FieldsClause)
			}
			if yyS[yypt-3].item != nil {
				x.LinesInfo = yyS[yypt-3].item.(*ast.LinesClause)
			}
			if yyS[yypt-0].item != nil {
				x.ColumnAssignments = yyS[yypt-0].item.([]*ast.Assignment)
			}
			columns := []*ast.ColumnName{}
			for _, v := range x.ColumnsAndUserVars {
				if v.ColumnName != nil {
					columns = append(columns, v.ColumnName)
				}
			}
			x.Columns = columns

			parser.yyVAL.statement = x
		}
	case 1697:
		{
			parser.yyVAL.item = uint64(0)
		}
	case 1698:
		{
			parser.yyVAL.item = getUint64FromNUM(yyS[yypt-1].item)
		}
	case 1701:
		{
			parser.yyVAL.item = nil
		}
	case 1702:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1703:
		{
			escape := "\\"
			parser.yyVAL.item = &ast.FieldsClause{
				Terminated: "\t",
				Escaped:    escape[0],
			}
		}
	case 1704:
		{
			fieldsClause := &ast.FieldsClause{
				Terminated: "\t",
				Escaped:    []byte("\\")[0],
			}
			fieldItems := yyS[yypt-0].item.([]*ast.FieldItem)
			for _, item := range fieldItems {
				switch item.Type {
				case ast.Terminated:

license_type: permissive

branch_name: refs/heads/master

extension: go


text:
fieldsClause.Terminated = item.Value
				case ast.Enclosed:
					var enclosed byte
					if len(item.Value) > 0 {
						enclosed = item.Value[0]
					}
					fieldsClause.Enclosed = enclosed
				case ast.Escaped:
					var escaped byte
					if len(item.Value) > 0 {
						escaped = item.Value[0]
					}
					fieldsClause.Escaped = escaped
				}
			}
			parser.yyVAL.item = fieldsClause
		}
	case 1707:
		{
			fieldItems := yyS[yypt-1].item.([]*ast.FieldItem)
			parser.yyVAL.item = append(fieldItems, yyS[yypt-0].item.(*ast.FieldItem))
		}
	case 1708:
		{
			fieldItems := make([]*ast.FieldItem, 1, 1)
			fieldItems[0] = yyS[yypt-0].item.(*ast.FieldItem)
			parser.yyVAL.item = fieldItems
		}
	case 1709:
		{
			parser.yyVAL.item = &ast.FieldItem{
				Type:  ast.Terminated,
				Value: yyS[yypt-0].item.(string),
			}
		}
	case 1710:
		{
			str := yyS[yypt-0].item.(string)
			if str != "\\" && len(str) > 1 {
				yylex.AppendError(ErrWrongFieldTerminators.GenWithStackByArgs())
				return 1
			}
			parser.yyVAL.item = &ast.FieldItem{
				Type:  ast.Enclosed,
				Value: str,
			}
		}
	case 1711:
		{
			str := yyS[yypt-0].item.(string)
			if str != "\\" && len(str) > 1 {
				yylex.AppendError(ErrWrongFieldTerminators.GenWithStackByArgs())
				return 1
			}
			parser.yyVAL.item = &ast.FieldItem{
				Type:  ast.Enclosed,
				Value: str,
			}
		}
	case 1712:
		{
			str := yyS[yypt-0].item.(string)
			if str != "\\" && len(str) > 1 {
				yylex.AppendError(ErrWrongFieldTerminators.GenWithStackByArgs())
				return 1
			}
			parser.yyVAL.item = &ast.FieldItem{
				Type:  ast.Escaped,
				Value: str,
			}
		}
	case 1713:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1714:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.BinaryLiteral).ToString()
		}
	case 1715:
		{
			parser.yyVAL.item = yyS[yypt-0].item.(ast.BinaryLiteral).ToString()
		}
	case 1716:
		{
			parser.yyVAL.item = &ast.LinesClause{Terminated: "\n"}
		}
	case 1717:
		{
			parser.yyVAL.item = &ast.LinesClause{Starting: yyS[yypt-1].item.(string), Terminated: yyS[yypt-0].item.(string)}
		}
	case 1718:
		{
			parser.yyVAL.item = ""
		}
	case 1719:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1720:
		{
			parser.yyVAL.item = "\n"
		}
	case 1721:
		{
			parser.yyVAL.item = yyS[yypt-0].ident
		}
	case 1722:
		{
			parser.yyVAL.item = nil
		}
	case 1723:
		{
			parser.yyVAL.item = yyS[yypt-0].item
		}
	case 1724:
		{
			l := yyS[yypt-2].item.([]*ast.Assignment)
			parser.yyVAL.item = append(l, yyS[yypt-0].item.(*ast.Assignment))
		}
	case 1725:
		{
			parser.yyVAL.item = []*ast.Assignment{yyS[yypt-0].item.(*ast.Assignment)}
		}
	case 1726:
		{
			parser.yyVAL.item = &ast.Assignment{
				Column: yyS[yypt-2].expr.(*ast.ColumnNameExpr).Name,
				Expr:   yyS[yypt-0].expr,
			}

		}
	case 1727:
		{
			parser.yyVAL.statement = &ast.UnlockTablesStmt{}
		}
	case 1728:
		{
			parser.yyVAL.statement = &ast.LockTablesStmt{
				TableLocks: yyS[yypt-0].item.([]ast.TableLock),
			}
		}
	case 1731:
		{
			parser.yyVAL.item = ast.TableLock{
				Table: yyS[yypt-1].item.(*ast.TableName),
				Type:  yyS[yypt-0].item.(model.TableLockType),
			}
		}
	case 1732:
		{
			parser.yyVAL.item = model.TableLockRead
		}
	case 1733:
		{
			parser.yyVAL.item = model.TableLockReadLocal
		}
	case 1734:
		{
			parser.yyVAL.item = model.TableLockWrite
		}
	case 1735:
		{
			parser.yyVAL.item = model.TableLockWriteLocal
		}
	case 1736:
		{
			parser.yyVAL.item = []ast.TableLock{yyS[yypt-0].item.(ast.TableLock)}
		}
	case 1737:
		{
			parser.yyVAL.item = append(yyS[yypt-2].item.([]ast.TableLock), yyS[yypt-0].item.(ast.TableLock))
		}
	case 1738:
		{
			parser.yyVAL.statement = &ast.KillStmt{
				ConnectionID:  getUint64FromNUM(yyS[yypt-0].item),
				TiDBExtension: yyS[yypt-1].item.(bool),
			}
		}
	case 1739:
		{
			parser.yyVAL.statement = &ast.KillStmt{
				ConnectionID:  getUint64FromNUM(yyS[yypt-0].item),
				TiDBExtension: yyS[yypt-2].item.(bool),
			}
		}
	case 1740:
		{
			parser.yyVAL.statement = &ast.KillStmt{
				ConnectionID:  getUint64FromNUM(yyS[yypt-0].item),
				Query:         true,
				TiDBExtension: yyS[yypt-2].item.(bool),
			}
		}
	case 1741:
		{
			parser.yyVAL.item = false
		}
	case 1742:
		{
			parser.yyVAL.item = true
		}
	case 1743:
		{
			parser.yyVAL.statement = &ast.LoadStatsStmt{
				Path: yyS[yypt-0].ident,
			}
		}

	}

	if yyEx != nil && yyEx.Reduced(r, exState, &parser.yyVAL) {
		return -1
	}
	goto yystack /* stack new state and value */
}


text:
package resources

import (
	"sort"

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

func (r IdentifiedResources) List(labelSelector labels.Selector) ([]Resource, error) {
	defer r.logger.DebugFunc("List").Finish()

	resTypes, err := r.resourceTypes.All()
	if err != nil {
		return nil, err
	}

	// TODO non-listable types
	resTypes = Listable(resTypes)

	// TODO eliminating events
	resTypes = NonMatching(resTypes, ResourceRef{
		schema.GroupVersionResource{Version: "v1", Resource: "events"},
	})

	// TODO eliminating component statuses
	resTypes = NonMatching(resTypes, ResourceRef{
		schema.GroupVersionResource{Version: "v1", Resource: "componentstatuses"},
	})

	allOpts := ResourcesAllOpts{
		ListOpts: &metav1.ListOptions{
			LabelSelector: labelSelector.String(),
		},
	}

	resources, err := r.resources.All(resTypes, allOpts)
	if err != nil {
		return nil, err
	}

	// Mark resources that were not created by kapp as transient
	for i, res := range resources {
		if !NewIdentityAnnotation(res).Valid() {
			res.MarkTransient(true)
			resources[i] = res
		}
	}

	return r.pickPreferredVersions(resources)
}

func (r IdentifiedResources) pickPreferredVersions(resources []Resource) ([]Resource, error) {
	var result []Resource

	uniqueByID := map[string][]Resource{}

	for _, res := range resources {
		uniqueByID[res.UID()] = append(uniqueByID[res.UID()], res)
	}

	for _, rs := range uniqueByID {
		var matched bool

		for _, res := range rs {
			idAnn := NewIdentityAnnotation(res)

			if idAnn.MatchesVersion() {
				err := idAnn.RemoveMod().Apply(res)
				if err != nil {
					return nil, err
				}

				result = append(result, res)
				matched = true
				break
			}
		}

		if !matched {
			// Sort to have some stability
			sort.Slice(rs, func(i, j int) bool { return rs[i].APIVersion() < rs[j].APIVersion() })
			// TODO use preferred version from the api
			result = append(result, rs[0])
		}
	}

	return result, nil
}

repository: rochacon/kapp

repo_name: rochacon/kapp