update vendor

342fd27e · martianzhang · 6734ef20 · 342fd27e · 342fd27e · 342fd27e
24 changed file
--- a/vendor/github.com/pingcap/parser/ast/ddl.go
+++ b/vendor/github.com/pingcap/parser/ast/ddl.go
@@ -14,10 +14,14 @@
 package ast

 import (
+	"strings"
+
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/auth"
 	. "github.com/pingcap/parser/format"
 	"github.com/pingcap/parser/model"
+	"github.com/pingcap/parser/mysql"
+	"github.com/pingcap/parser/terror"
 	"github.com/pingcap/parser/types"
 )

@@ -862,6 +866,13 @@ func (n *CreateTableStmt) Accept(v Visitor) (Node, bool) {
 		}
 		n.Select = node.(ResultSetNode)
 	}
+	if n.Partition != nil {
+		node, ok := n.Partition.Accept(v)
+		if !ok {
+			return n, false
+		}
+		n.Partition = node.(*PartitionOptions)
+	}

 	return v.Leave(n)
 }
@@ -1020,6 +1031,7 @@ type CreateViewStmt struct {
 	ViewName    *TableName
 	Cols        []model.CIStr
 	Select      StmtNode
+	SchemaCols  []model.CIStr
 	Algorithm   model.ViewAlgorithm
 	Definer     *auth.UserIdentity
 	Security    model.ViewSecurity
@@ -1219,6 +1231,68 @@ func (n *DropIndexStmt) Accept(v Visitor) (Node, bool) {
 	return v.Leave(n)
 }

+// LockTablesStmt is a statement to lock tables.
+type LockTablesStmt struct {
+	ddlNode
+
+	TableLocks []TableLock
+}
+
+// TableLock contains the table name and lock type.
+type TableLock struct {
+	Table *TableName
+	Type  model.TableLockType
+}
+
+// Accept implements Node Accept interface.
+func (n *LockTablesStmt) Accept(v Visitor) (Node, bool) {
+	newNode, skipChildren := v.Enter(n)
+	if skipChildren {
+		return v.Leave(newNode)
+	}
+	n = newNode.(*LockTablesStmt)
+	for i := range n.TableLocks {
+		node, ok := n.TableLocks[i].Table.Accept(v)
+		if !ok {
+			return n, false
+		}
+		n.TableLocks[i].Table = node.(*TableName)
+	}
+	return v.Leave(n)
+}
+
+// Restore implements Node interface.
+func (n *LockTablesStmt) Restore(ctx *RestoreCtx) error {
+	ctx.WriteKeyWord("LOCK TABLES ")
+	for i, tl := range n.TableLocks {
+		if i != 0 {
+			ctx.WritePlain(", ")
+		}
+		if err := tl.Table.Restore(ctx); err != nil {
+			return errors.Annotate(err, "An error occurred while add index")
+		}
+		ctx.WriteKeyWord(" " + tl.Type.String())
+	}
+	return nil
+}
+
+// UnlockTablesStmt is a statement to unlock tables.
+type UnlockTablesStmt struct {
+	ddlNode
+}
+
+// Accept implements Node Accept interface.
+func (n *UnlockTablesStmt) Accept(v Visitor) (Node, bool) {
+	_, _ = v.Enter(n)
+	return v.Leave(n)
+}
+
+// Restore implements Node interface.
+func (n *UnlockTablesStmt) Restore(ctx *RestoreCtx) error {
+	ctx.WriteKeyWord("UNLOCK TABLES")
+	return nil
+}
+
 // TableOptionType is the type for TableOption
 type TableOptionType int

@@ -1244,6 +1318,10 @@ const (
 	TableOptionShardRowID
 	TableOptionPreSplitRegion
 	TableOptionPackKeys
+	TableOptionTablespace
+	TableOptionNodegroup
+	TableOptionDataDirectory
+	TableOptionIndexDirectory
 )

 // RowFormat types
@@ -1398,6 +1476,21 @@ func (n *TableOption) Restore(ctx *RestoreCtx) error {
 		ctx.WritePlain("= ")
 		ctx.WriteKeyWord("DEFAULT")
 		ctx.WritePlain(" /* TableOptionPackKeys is not supported */ ")
+	case TableOptionTablespace:
+		ctx.WriteKeyWord("TABLESPACE ")
+		ctx.WritePlain("= ")
+		ctx.WriteName(n.StrValue)
+	case TableOptionNodegroup:
+		ctx.WriteKeyWord("NODEGROUP ")
+		ctx.WritePlainf("= %d", n.UintValue)
+	case TableOptionDataDirectory:
+		ctx.WriteKeyWord("DATA DIRECTORY ")
+		ctx.WritePlain("= ")
+		ctx.WriteString(n.StrValue)
+	case TableOptionIndexDirectory:
+		ctx.WriteKeyWord("INDEX DIRECTORY ")
+		ctx.WritePlain("= ")
+		ctx.WriteString(n.StrValue)
 	default:
 		return errors.Errorf("invalid TableOption: %d", n.Tp)
 	}
@@ -1482,6 +1575,9 @@ const (
 	AlterTableCoalescePartitions
 	AlterTableDropPartition
 	AlterTableTruncatePartition
+	AlterTablePartition
+	AlterTableEnableKeys
+	AlterTableDisableKeys

 	// TODO: Add more actions
 )
@@ -1558,6 +1654,8 @@ type AlterTableSpec struct {
 	Comment         string
 	FromKey         model.CIStr
 	ToKey           model.CIStr
+	Partition       *PartitionOptions
+	PartitionNames  []model.CIStr
 	PartDefinitions []*PartitionDefinition
 	Num             uint64
 }
@@ -1710,10 +1808,28 @@ func (n *AlterTableSpec) Restore(ctx *RestoreCtx) error {
 		ctx.WritePlainf("%d", n.Num)
 	case AlterTableDropPartition:
 		ctx.WriteKeyWord("DROP PARTITION ")
-		ctx.WriteName(n.Name)
+		for i, name := range n.PartitionNames {
+			if i != 0 {
+				ctx.WritePlain(",")
+			}
+			ctx.WriteName(name.O)
+		}
 	case AlterTableTruncatePartition:
 		ctx.WriteKeyWord("TRUNCATE PARTITION ")
-		ctx.WriteName(n.Name)
+		for i, name := range n.PartitionNames {
+			if i != 0 {
+				ctx.WritePlain(",")
+			}
+			ctx.WriteName(name.O)
+		}
+	case AlterTablePartition:
+		if err := n.Partition.Restore(ctx); err != nil {
+			return errors.Annotate(err, "An error occurred while restore AlterTableSpec.Partition")
+		}
+	case AlterTableEnableKeys:
+		ctx.WriteKeyWord("ENABLE KEYS")
+	case AlterTableDisableKeys:
+		ctx.WriteKeyWord("DISABLE KEYS")
 	default:
 		// TODO: not support
 		ctx.WritePlainf(" /* AlterTableType(%d) is not supported */ ", n.Tp)
@@ -1782,7 +1898,7 @@ func (n *AlterTableStmt) Restore(ctx *RestoreCtx) error {
 		return errors.Annotate(err, "An error occurred while restore AlterTableStmt.Table")
 	}
 	for i, spec := range n.Specs {
-		if i == 0 {
+		if i == 0 || spec.Tp == AlterTablePartition {
 			ctx.WritePlain(" ")
 		} else {
 			ctx.WritePlain(", ")
@@ -1848,94 +1964,474 @@ func (n *TruncateTableStmt) Accept(v Visitor) (Node, bool) {
 	return v.Leave(n)
 }

+var (
+	ErrNoParts                              = terror.ClassDDL.NewStd(mysql.ErrNoParts)
+	ErrPartitionColumnList                  = terror.ClassDDL.NewStd(mysql.ErrPartitionColumnList)
+	ErrPartitionRequiresValues              = terror.ClassDDL.NewStd(mysql.ErrPartitionRequiresValues)
+	ErrPartitionsMustBeDefined              = terror.ClassDDL.NewStd(mysql.ErrPartitionsMustBeDefined)
+	ErrPartitionWrongNoPart                 = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongNoPart)
+	ErrPartitionWrongNoSubpart              = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongNoSubpart)
+	ErrPartitionWrongValues                 = terror.ClassDDL.NewStd(mysql.ErrPartitionWrongValues)
+	ErrRowSinglePartitionField              = terror.ClassDDL.NewStd(mysql.ErrRowSinglePartitionField)
+	ErrSubpartition                         = terror.ClassDDL.NewStd(mysql.ErrSubpartition)
+	ErrSystemVersioningWrongPartitions      = terror.ClassDDL.NewStd(mysql.ErrSystemVersioningWrongPartitions)
+	ErrTooManyValues                        = terror.ClassDDL.NewStd(mysql.ErrTooManyValues)
+	ErrWrongPartitionTypeExpectedSystemTime = terror.ClassDDL.NewStd(mysql.ErrWrongPartitionTypeExpectedSystemTime)
+)
+
+type SubPartitionDefinition struct {
+	Name    model.CIStr
+	Options []*TableOption
+}
+
+func (spd *SubPartitionDefinition) Restore(ctx *RestoreCtx) error {
+	ctx.WriteKeyWord("SUBPARTITION ")
+	ctx.WriteName(spd.Name.O)
+	for i, opt := range spd.Options {
+		ctx.WritePlain(" ")
+		if err := opt.Restore(ctx); err != nil {
+			return errors.Annotatef(err, "An error occurred while restore SubPartitionDefinition.Options[%d]", i)
+		}
+	}
+	return nil
+}
+
+type PartitionDefinitionClause interface {
+	restore(ctx *RestoreCtx) error
+	acceptInPlace(v Visitor) bool
+	// Validate checks if the clause is consistent with the given options.
+	// `pt` can be 0 and `columns` can be -1 to skip checking the clause against
+	// the partition type or number of columns in the expression list.
+	Validate(pt model.PartitionType, columns int) error
+}
+
+type PartitionDefinitionClauseNone struct{}
+
+func (n *PartitionDefinitionClauseNone) restore(ctx *RestoreCtx) error {
+	return nil
+}
+
+func (n *PartitionDefinitionClauseNone) acceptInPlace(v Visitor) bool {
+	return true
+}
+
+func (n *PartitionDefinitionClauseNone) Validate(pt model.PartitionType, columns int) error {
+	switch pt {
+	case 0:
+	case model.PartitionTypeRange:
+		return ErrPartitionRequiresValues.GenWithStackByArgs("RANGE", "LESS THAN")
+	case model.PartitionTypeList:
+		return ErrPartitionRequiresValues.GenWithStackByArgs("LIST", "IN")
+	case model.PartitionTypeSystemTime:
+		return ErrSystemVersioningWrongPartitions
+	}
+	return nil
+}
+
+type PartitionDefinitionClauseLessThan struct {
+	Exprs []ExprNode
+}
+
+func (n *PartitionDefinitionClauseLessThan) restore(ctx *RestoreCtx) error {
+	ctx.WriteKeyWord(" VALUES LESS THAN ")
+	ctx.WritePlain("(")
+	for i, expr := range n.Exprs {
+		if i != 0 {
+			ctx.WritePlain(", ")
+		}
+		if err := expr.Restore(ctx); err != nil {
+			return errors.Annotatef(err, "An error occurred while restore PartitionDefinitionClauseLessThan.Exprs[%d]", i)
+		}
+	}
+	ctx.WritePlain(")")
+	return nil
+}
+
+func (n *PartitionDefinitionClauseLessThan) acceptInPlace(v Visitor) bool {
+	for i, expr := range n.Exprs {
+		newExpr, ok := expr.Accept(v)
+		if !ok {
+			return false
+		}
+		n.Exprs[i] = newExpr.(ExprNode)
+	}
+	return true
+}
+
+func (n *PartitionDefinitionClauseLessThan) Validate(pt model.PartitionType, columns int) error {
+	switch pt {
+	case model.PartitionTypeRange, 0:
+	default:
+		return ErrPartitionWrongValues.GenWithStackByArgs("RANGE", "LESS THAN")
+	}
+
+	switch {
+	case columns == 0 && len(n.Exprs) != 1:
+		return ErrTooManyValues.GenWithStackByArgs("RANGE")
+	case columns > 0 && len(n.Exprs) != columns:
+		return ErrPartitionColumnList
+	}
+	return nil
+}
+
+type PartitionDefinitionClauseIn struct {
+	Values [][]ExprNode
+}
+
+func (n *PartitionDefinitionClauseIn) restore(ctx *RestoreCtx) error {
+	// we special-case an empty list of values to mean MariaDB's "DEFAULT" clause.
+	if len(n.Values) == 0 {
+		ctx.WriteKeyWord(" DEFAULT")
+		return nil
+	}
+
+	ctx.WriteKeyWord(" VALUES IN ")
+	ctx.WritePlain("(")
+	for i, valList := range n.Values {
+		if i != 0 {
+			ctx.WritePlain(", ")
+		}
+		if len(valList) == 1 {
+			if err := valList[0].Restore(ctx); err != nil {
+				return errors.Annotatef(err, "An error occurred while restore PartitionDefinitionClauseIn.Values[%d][0]", i)
+			}
+		} else {
+			ctx.WritePlain("(")
+			for j, val := range valList {
+				if j != 0 {
+					ctx.WritePlain(", ")
+				}
+				if err := val.Restore(ctx); err != nil {
+					return errors.Annotatef(err, "An error occurred while restore PartitionDefinitionClauseIn.Values[%d][%d]", i, j)
+				}
+			}
+			ctx.WritePlain(")")
+		}
+	}
+	ctx.WritePlain(")")
+	return nil
+}
+
+func (n *PartitionDefinitionClauseIn) acceptInPlace(v Visitor) bool {
+	for _, valList := range n.Values {
+		for j, val := range valList {
+			newVal, ok := val.Accept(v)
+			if !ok {
+				return false
+			}
+			valList[j] = newVal.(ExprNode)
+		}
+	}
+	return true
+}
+
+func (n *PartitionDefinitionClauseIn) Validate(pt model.PartitionType, columns int) error {
+	switch pt {
+	case model.PartitionTypeList, 0:
+	default:
+		return ErrPartitionWrongValues.GenWithStackByArgs("LIST", "IN")
+	}
+
+	if len(n.Values) == 0 {
+		return nil
+	}
+
+	expectedColCount := len(n.Values[0])
+	for _, val := range n.Values[1:] {
+		if len(val) != expectedColCount {
+			return ErrPartitionColumnList
+		}
+	}
+
+	switch {
+	case columns == 0 && expectedColCount != 1:
+		return ErrRowSinglePartitionField
+	case columns > 0 && expectedColCount != columns:
+		return ErrPartitionColumnList
+	}
+	return nil
+}
+
+type PartitionDefinitionClauseHistory struct {
+	Current bool
+}
+
+func (n *PartitionDefinitionClauseHistory) restore(ctx *RestoreCtx) error {
+	if n.Current {
+		ctx.WriteKeyWord(" CURRENT")
+	} else {
+		ctx.WriteKeyWord(" HISTORY")
+	}
+	return nil
+}
+
+func (n *PartitionDefinitionClauseHistory) acceptInPlace(v Visitor) bool {
+	return true
+}
+
+func (n *PartitionDefinitionClauseHistory) Validate(pt model.PartitionType, columns int) error {
+	switch pt {
+	case 0, model.PartitionTypeSystemTime:
+	default:
+		return ErrWrongPartitionTypeExpectedSystemTime
+	}
+
+	return nil
+}
+
 // PartitionDefinition defines a single partition.
 type PartitionDefinition struct {
-	Name     model.CIStr
-	LessThan []ExprNode
-	MaxValue bool
-	Comment  string
+	Name    model.CIStr
+	Clause  PartitionDefinitionClause
+	Options []*TableOption
+	Sub     []*SubPartitionDefinition
+}
+
+// Comment returns the comment option given to this definition.
+// The second return value indicates if the comment option exists.
+func (n *PartitionDefinition) Comment() (string, bool) {
+	for _, opt := range n.Options {
+		if opt.Tp == TableOptionComment {
+			return opt.StrValue, true
+		}
+	}
+	return "", false
+}
+
+func (n *PartitionDefinition) acceptInPlace(v Visitor) bool {
+	return n.Clause.acceptInPlace(v)
 }

 // Restore implements Node interface.
 func (n *PartitionDefinition) Restore(ctx *RestoreCtx) error {
 	ctx.WriteKeyWord("PARTITION ")
 	ctx.WriteName(n.Name.O)
-	if n.LessThan != nil {
-		ctx.WriteKeyWord(" VALUES LESS THAN ")
-		ctx.WritePlain("(")
-		for k, less := range n.LessThan {
-			if k != 0 {
-				ctx.WritePlain(", ")
+
+	if err := n.Clause.restore(ctx); err != nil {
+		return errors.Annotate(err, "An error occurred while restore PartitionDefinition.Clause")
+	}
+
+	for i, opt := range n.Options {
+		ctx.WritePlain(" ")
+		if err := opt.Restore(ctx); err != nil {
+			return errors.Annotatef(err, "An error occurred while restore PartitionDefinition.Options[%d]", i)
+		}
+	}
+
+	if len(n.Sub) > 0 {
+		ctx.WritePlain(" (")
+		for i, spd := range n.Sub {
+			if i != 0 {
+				ctx.WritePlain(",")
 			}
-			if err := less.Restore(ctx); err != nil {
-				return errors.Annotatef(err, "An error occurred while restore PartitionDefinition.LessThan[%d]", k)
+			if err := spd.Restore(ctx); err != nil {
+				return errors.Annotatef(err, "An error occurred while restore PartitionDefinition.Sub[%d]", i)
 			}
 		}
 		ctx.WritePlain(")")
 	}
-	if n.Comment != "" {
-		ctx.WriteKeyWord(" COMMENT ")
-		ctx.WritePlain("= ")
-		ctx.WriteString(n.Comment)
-	}
+
 	return nil
 }

-// PartitionOptions specifies the partition options.
-type PartitionOptions struct {
-	Tp          model.PartitionType
-	Expr        ExprNode
+// PartitionMethod describes how partitions or subpartitions are constructed.
+type PartitionMethod struct {
+	// Tp is the type of the partition function
+	Tp model.PartitionType
+	// Linear is a modifier to the HASH and KEY type for choosing a different
+	// algorithm
+	Linear bool
+	// Expr is an expression used as argument of HASH, RANGE, LIST and
+	// SYSTEM_TIME types
+	Expr ExprNode
+	// ColumnNames is a list of column names used as argument of KEY,
+	// RANGE COLUMNS and LIST COLUMNS types
 	ColumnNames []*ColumnName
-	Definitions []*PartitionDefinition
-	Num         uint64
+	// Unit is a time unit used as argument of SYSTEM_TIME type
+	Unit ValueExpr
+	// Limit is a row count used as argument of the SYSTEM_TIME type
+	Limit uint64
+
+	// Num is the number of (sub)partitions required by the method.
+	Num uint64
 }

-func (n *PartitionOptions) Restore(ctx *RestoreCtx) error {
-	ctx.WriteKeyWord("PARTITION BY ")
-	switch n.Tp {
-	case model.PartitionTypeRange:
-		ctx.WriteKeyWord("RANGE ")
-	case model.PartitionTypeHash:
-		ctx.WriteKeyWord("HASH ")
-	case model.PartitionTypeList:
-		return errors.New("TiDB Parser ignore the `PartitionTypeList` type now")
-	default:
-		return errors.Errorf("invalid model.PartitionType: %d", n.Tp)
+// Restore implements the Node interface
+func (n *PartitionMethod) Restore(ctx *RestoreCtx) error {
+	if n.Linear {
+		ctx.WriteKeyWord("LINEAR ")
 	}
+	ctx.WriteKeyWord(n.Tp.String())

-	if n.Expr != nil {
-		ctx.WritePlain("(")
+	switch {
+	case n.Tp == model.PartitionTypeSystemTime:
+		if n.Expr != nil && n.Unit != nil {
+			ctx.WriteKeyWord(" INTERVAL ")
+			if err := n.Expr.Restore(ctx); err != nil {
+				return errors.Annotate(err, "An error occurred while restore PartitionMethod.Expr")
+			}
+
+			// Here the Unit string should not be quoted.
+			// TODO: This is a temporary workaround that should be changed once something like "Keyword Expression" is implemented.
+			var sb strings.Builder
+			if err := n.Unit.Restore(NewRestoreCtx(0, &sb)); err != nil {
+				return errors.Annotate(err, "An error occurred while restore PartitionMethod.Unit")
+			}
+			ctx.WritePlain(" ")
+			ctx.WriteKeyWord(sb.String())
+		}
+
+	case n.Expr != nil:
+		ctx.WritePlain(" (")
 		if err := n.Expr.Restore(ctx); err != nil {
-			return errors.Annotate(err, "An error occurred while restore PartitionOptions Expr")
+			return errors.Annotate(err, "An error occurred while restore PartitionMethod.Expr")
 		}
-		ctx.WritePlain(") ")
-	}
-	if len(n.ColumnNames) > 0 {
-		ctx.WriteKeyWord("COLUMNS")
-		ctx.WritePlain("(")
+		ctx.WritePlain(")")
+
+	default:
+		if n.Tp == model.PartitionTypeRange || n.Tp == model.PartitionTypeList {
+			ctx.WriteKeyWord(" COLUMNS")
+		}
+		ctx.WritePlain(" (")
 		for i, col := range n.ColumnNames {
 			if i > 0 {
 				ctx.WritePlain(",")
 			}
 			if err := col.Restore(ctx); err != nil {
-				return errors.Annotatef(err, "An error occurred while splicing PartitionOptions ColumnName: [%v]", i)
+				return errors.Annotatef(err, "An error occurred while splicing PartitionMethod.ColumnName[%d]", i)
 			}
 		}
-		ctx.WritePlain(") ")
+		ctx.WritePlain(")")
+	}
+
+	if n.Limit > 0 {
+		ctx.WriteKeyWord(" LIMIT ")
+		ctx.WritePlainf("%d", n.Limit)
+	}
+
+	return nil
+}
+
+// acceptInPlace is like Node.Accept but does not allow replacing the node itself.
+func (n *PartitionMethod) acceptInPlace(v Visitor) bool {
+	if n.Expr != nil {
+		expr, ok := n.Expr.Accept(v)
+		if !ok {
+			return false
+		}
+		n.Expr = expr.(ExprNode)
+	}
+	for i, colName := range n.ColumnNames {
+		newColName, ok := colName.Accept(v)
+		if !ok {
+			return false
+		}
+		n.ColumnNames[i] = newColName.(*ColumnName)
+	}
+	if n.Unit != nil {
+		unit, ok := n.Unit.Accept(v)
+		if !ok {
+			return false
+		}
+		n.Unit = unit.(ValueExpr)
+	}
+	return true
+}
+
+// PartitionOptions specifies the partition options.
+type PartitionOptions struct {
+	node
+	PartitionMethod
+	Sub         *PartitionMethod
+	Definitions []*PartitionDefinition
+}
+
+// Validate checks if the partition is well-formed.
+func (n *PartitionOptions) Validate() error {
+	// if both a partition list and the partition numbers are specified, their values must match
+	if n.Num != 0 && len(n.Definitions) != 0 && n.Num != uint64(len(n.Definitions)) {
+		return ErrPartitionWrongNoPart
+	}
+	// now check the subpartition count
+	if len(n.Definitions) > 0 {
+		// ensure the subpartition count for every partitions are the same
+		// then normalize n.Num and n.Sub.Num so equality comparison works.
+		n.Num = uint64(len(n.Definitions))
+
+		subDefCount := len(n.Definitions[0].Sub)
+		for _, pd := range n.Definitions[1:] {
+			if len(pd.Sub) != subDefCount {
+				return ErrPartitionWrongNoSubpart
+			}
+		}
+		if n.Sub != nil {
+			if n.Sub.Num != 0 && subDefCount != 0 && n.Sub.Num != uint64(subDefCount) {
+				return ErrPartitionWrongNoSubpart
+			}
+			if subDefCount != 0 {
+				n.Sub.Num = uint64(subDefCount)
+			}
+		} else if subDefCount != 0 {
+			return ErrSubpartition
+		}
+	}
+
+	switch n.Tp {
+	case model.PartitionTypeHash, model.PartitionTypeKey:
+		if n.Num == 0 {
+			n.Num = 1
+		}
+	case model.PartitionTypeRange, model.PartitionTypeList:
+		if len(n.Definitions) == 0 {
+			return ErrPartitionsMustBeDefined.GenWithStackByArgs(n.Tp)
+		}
+	case model.PartitionTypeSystemTime:
+		if len(n.Definitions) < 2 {
+			return ErrSystemVersioningWrongPartitions
+		}
+	}
+
+	for _, pd := range n.Definitions {
+		// ensure the partition definition types match the methods,
+		// e.g. RANGE partitions only allows VALUES LESS THAN
+		if err := pd.Clause.Validate(n.Tp, len(n.ColumnNames)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (n *PartitionOptions) Restore(ctx *RestoreCtx) error {
+	ctx.WriteKeyWord("PARTITION BY ")
+	if err := n.PartitionMethod.Restore(ctx); err != nil {
+		return errors.Annotate(err, "An error occurred while restore PartitionOptions.PartitionMethod")
 	}
-	if n.Num > 0 {
-		ctx.WriteKeyWord("PARTITIONS ")
+
+	if n.Num > 0 && len(n.Definitions) == 0 {
+		ctx.WriteKeyWord(" PARTITIONS ")
 		ctx.WritePlainf("%d", n.Num)
 	}

+	if n.Sub != nil {
+		ctx.WriteKeyWord(" SUBPARTITION BY ")
+		if err := n.Sub.Restore(ctx); err != nil {
+			return errors.Annotate(err, "An error occurred while restore PartitionOptions.Sub")
+		}
+		if n.Sub.Num > 0 {
+			ctx.WriteKeyWord(" SUBPARTITIONS ")
+			ctx.WritePlainf("%d", n.Sub.Num)
+		}
+	}
+
 	if len(n.Definitions) > 0 {
-		ctx.WritePlain("(")
+		ctx.WritePlain(" (")
 		for i, def := range n.Definitions {
 			if i > 0 {
 				ctx.WritePlain(",")
 			}
 			if err := def.Restore(ctx); err != nil {
-				return errors.Annotatef(err, "An error occurred while splicing PartitionOptions Definitions: [%v]", i)
+				return errors.Annotatef(err, "An error occurred while restore PartitionOptions.Definitions[%d]", i)
 			}
 		}
 		ctx.WritePlain(")")
@@ -1944,6 +2440,27 @@ func (n *PartitionOptions) Restore(ctx *RestoreCtx) error {
 	return nil
 }

+func (n *PartitionOptions) Accept(v Visitor) (Node, bool) {
+	newNode, skipChildren := v.Enter(n)
+	if skipChildren {
+		return v.Leave(newNode)
+	}
+
+	n = newNode.(*PartitionOptions)
+	if !n.PartitionMethod.acceptInPlace(v) {
+		return n, false
+	}
+	if n.Sub != nil && !n.Sub.acceptInPlace(v) {
+		return n, false
+	}
+	for _, def := range n.Definitions {
+		if !def.acceptInPlace(v) {
+			return n, false
+		}
+	}
+	return v.Leave(n)
+}
+
 // RecoverTableStmt is a statement to recover dropped table.
 type RecoverTableStmt struct {
 	ddlNode

--- a/vendor/github.com/pingcap/parser/ast/dml.go
+++ b/vendor/github.com/pingcap/parser/ast/dml.go
@@ -31,7 +31,7 @@ var (
 	_ DMLNode = &SelectStmt{}
 	_ DMLNode = &ShowStmt{}
 	_ DMLNode = &LoadDataStmt{}
-	_ DMLNode = &SplitIndexRegionStmt{}
+	_ DMLNode = &SplitRegionStmt{}

 	_ Node = &Assignment{}
 	_ Node = &ByItem{}
@@ -777,6 +777,18 @@ func (n *SelectStmt) Restore(ctx *RestoreCtx) error {
 		ctx.WritePlain(" ")
 	}

+	if n.SelectStmtOpts.SQLSmallResult {
+		ctx.WriteKeyWord("SQL_SMALL_RESULT ")
+	}
+
+	if n.SelectStmtOpts.SQLBigResult {
+		ctx.WriteKeyWord("SQL_BIG_RESULT ")
+	}
+
+	if n.SelectStmtOpts.SQLBufferResult {
+		ctx.WriteKeyWord("SQL_BUFFER_RESULT ")
+	}
+
 	if !n.SelectStmtOpts.SQLCache {
 		ctx.WriteKeyWord("SQL_NO_CACHE ")
 	}
@@ -2404,60 +2416,119 @@ func (n *FrameBound) Accept(v Visitor) (Node, bool) {
 	return v.Leave(n)
 }

-type SplitIndexRegionStmt struct {
+type SplitRegionStmt struct {
 	dmlNode

-	Table      *TableName
-	IndexName  string
+	Table     *TableName
+	IndexName model.CIStr
+
+	SplitOpt *SplitOption
+}
+
+type SplitOption struct {
+	Lower      []ExprNode
+	Upper      []ExprNode
+	Num        int64
 	ValueLists [][]ExprNode
 }

-func (n *SplitIndexRegionStmt) Restore(ctx *RestoreCtx) error {
+func (n *SplitRegionStmt) Restore(ctx *RestoreCtx) error {
 	ctx.WriteKeyWord("SPLIT TABLE ")
 	if err := n.Table.Restore(ctx); err != nil {
 		return errors.Annotate(err, "An error occurred while restore SplitIndexRegionStmt.Table")
 	}
-	ctx.WriteKeyWord(" INDEX ")
-	ctx.WriteName(n.IndexName)
-	ctx.WriteKeyWord(" BY ")
-	for i, row := range n.ValueLists {
-		if i != 0 {
-			ctx.WritePlain(",")
-		}
-		ctx.WritePlain("(")
-		for j, v := range row {
-			if j != 0 {
-				ctx.WritePlain(",")
-			}
-			if err := v.Restore(ctx); err != nil {
-				return errors.Annotatef(err, "An error occurred while restore SplitIndexRegionStmt.ValueLists[%d][%d]", i, j)
-			}
-		}
-		ctx.WritePlain(")")
+	if len(n.IndexName.L) > 0 {
+		ctx.WriteKeyWord(" INDEX ")
+		ctx.WriteName(n.IndexName.String())
 	}
-	return nil
+	ctx.WritePlain(" ")
+	err := n.SplitOpt.Restore(ctx)
+	return err
 }

-func (n *SplitIndexRegionStmt) Accept(v Visitor) (Node, bool) {
+func (n *SplitRegionStmt) Accept(v Visitor) (Node, bool) {
 	newNode, skipChildren := v.Enter(n)
 	if skipChildren {
 		return v.Leave(newNode)
 	}

-	n = newNode.(*SplitIndexRegionStmt)
+	n = newNode.(*SplitRegionStmt)
 	node, ok := n.Table.Accept(v)
 	if !ok {
 		return n, false
 	}
 	n.Table = node.(*TableName)
-	for i, list := range n.ValueLists {
+	for i, val := range n.SplitOpt.Lower {
+		node, ok := val.Accept(v)
+		if !ok {
+			return n, false
+		}
+		n.SplitOpt.Lower[i] = node.(ExprNode)
+	}
+	for i, val := range n.SplitOpt.Upper {
+		node, ok := val.Accept(v)
+		if !ok {
+			return n, false
+		}
+		n.SplitOpt.Upper[i] = node.(ExprNode)
+	}
+
+	for i, list := range n.SplitOpt.ValueLists {
 		for j, val := range list {
 			node, ok := val.Accept(v)
 			if !ok {
 				return n, false
 			}
-			n.ValueLists[i][j] = node.(ExprNode)
+			n.SplitOpt.ValueLists[i][j] = node.(ExprNode)
 		}
 	}
 	return v.Leave(n)
 }
+
+func (n *SplitOption) Restore(ctx *RestoreCtx) error {
+	if len(n.ValueLists) == 0 {
+		ctx.WriteKeyWord("BETWEEN ")
+		ctx.WritePlain("(")
+		for j, v := range n.Lower {
+			if j != 0 {
+				ctx.WritePlain(",")
+			}
+			if err := v.Restore(ctx); err != nil {
+				return errors.Annotatef(err, "An error occurred while restore SplitOption Lower")
+			}
+		}
+		ctx.WritePlain(")")
+
+		ctx.WriteKeyWord(" AND ")
+		ctx.WritePlain("(")
+		for j, v := range n.Upper {
+			if j != 0 {
+				ctx.WritePlain(",")
+			}
+			if err := v.Restore(ctx); err != nil {
+				return errors.Annotatef(err, "An error occurred while restore SplitOption Upper")
+			}
+		}
+		ctx.WritePlain(")")
+		ctx.WriteKeyWord(" REGIONS")
+		ctx.WritePlainf(" %d", n.Num)
+		return nil
+	}
+	ctx.WriteKeyWord("BY ")
+	for i, row := range n.ValueLists {
+		if i != 0 {
+			ctx.WritePlain(",")
+		}
+		ctx.WritePlain("(")
+		for j, v := range row {
+			if j != 0 {
+				ctx.WritePlain(",")
+			}
+			if err := v.Restore(ctx); err != nil {
+				return errors.Annotatef(err, "An error occurred while restore SplitOption.ValueLists[%d][%d]", i, j)
+			}
+		}
+		ctx.WritePlain(")")
+	}
+	return nil
+}
--- a/vendor/github.com/pingcap/parser/ast/misc.go
+++ b/vendor/github.com/pingcap/parser/ast/misc.go
@@ -1379,6 +1379,7 @@ const (
 	AdminChecksumTable
 	AdminShowSlow
 	AdminShowNextRowID
+	AdminReloadExprPushdownBlacklist
 )

 // HandleRange represents a range where handle value >= Begin and < End.
@@ -1547,6 +1548,8 @@ func (n *AdminStmt) Restore(ctx *RestoreCtx) error {
 		if err := n.ShowSlow.Restore(ctx); err != nil {
 			return errors.Annotate(err, "An error occurred while restore AdminStmt.ShowSlow")
 		}
+	case AdminReloadExprPushdownBlacklist:
+		ctx.WriteKeyWord("RELOAD EXPR_PUSHDOWN_BLACKLIST")
 	default:
 		return errors.New("Unsupported AdminStmt type")
 	}
@@ -1974,12 +1977,15 @@ func (i Ident) String() string {

 // SelectStmtOpts wrap around select hints and switches
 type SelectStmtOpts struct {
-	Distinct      bool
-	SQLCache      bool
-	CalcFoundRows bool
-	StraightJoin  bool
-	Priority      mysql.PriorityEnum
-	TableHints    []*TableOptimizerHint
+	Distinct        bool
+	SQLBigResult    bool
+	SQLBufferResult bool
+	SQLCache        bool
+	SQLSmallResult  bool
+	CalcFoundRows   bool
+	StraightJoin    bool
+	Priority        mysql.PriorityEnum
+	TableHints      []*TableOptimizerHint
 }

 // TableOptimizerHint is Table level optimizer hint

--- a/vendor/github.com/pingcap/parser/lexer.go
+++ b/vendor/github.com/pingcap/parser/lexer.go
@@ -58,6 +58,7 @@ type Scanner struct {
 }

 type specialCommentScanner interface {
+	stmtTexter
 	scan() (tok int, pos Pos, lit string)
 }

@@ -85,11 +86,18 @@ func (s *optimizerHintScanner) scan() (tok int, pos Pos, lit string) {
 	pos.Line += s.Pos.Line
 	pos.Col += s.Pos.Col
 	pos.Offset += s.Pos.Offset
-	if tok == 0 {
+	switch tok {
+	case 0:
 		if !s.end {
 			tok = hintEnd
 			s.end = true
 		}
+	case invalid:
+		// an optimizer hint is allowed to contain invalid characters, the
+		// remaining hints are just ignored.
+		// force advance the lexer even when encountering an invalid character
+		// to prevent infinite parser loop. (see issue #336)
+		s.r.inc()
 	}
 	return
 }
@@ -110,6 +118,10 @@ func (s *Scanner) reset(sql string) {
 }

 func (s *Scanner) stmtText() string {
+	if s.specialComment != nil {
+		return s.specialComment.stmtText()
+	}
+
 	endPos := s.r.pos().Offset
 	if s.r.s[endPos-1] == '\n' {
 		endPos = endPos - 1 // trim new line
@@ -220,6 +232,15 @@ func (s *Scanner) EnableWindowFunc(val bool) {
 	s.supportWindowFunc = val
 }

+// InheritScanner returns a new scanner object which inherits configurations from the parent scanner.
+func (s *Scanner) InheritScanner(sql string) *Scanner {
+	return &Scanner{
+		r:                 reader{s: sql},
+		sqlMode:           s.sqlMode,
+		supportWindowFunc: s.supportWindowFunc,
+	}
+}
+
 // NewScanner returns a new scanner object.
 func NewScanner(s string) *Scanner {
 	return &Scanner{r: reader{s: s}}
@@ -396,7 +417,7 @@ func startWithSlash(s *Scanner) (tok int, pos Pos, lit string) {
 			end := len(comment) - 2
 			sql := comment[begin:end]
 			s.specialComment = &optimizerHintScanner{
-				Scanner: NewScanner(sql),
+				Scanner: s.InheritScanner(sql),
 				Pos: Pos{
 					pos.Line,
 					pos.Col,
@@ -413,7 +434,7 @@ func startWithSlash(s *Scanner) (tok int, pos Pos, lit string) {
 		if strings.HasPrefix(comment, "/*!") {
 			sql := specCodePattern.ReplaceAllStringFunc(comment, TrimComment)
 			s.specialComment = &mysqlSpecificCodeScanner{
-				Scanner: NewScanner(sql),
+				Scanner: s.InheritScanner(sql),
 				Pos: Pos{
 					pos.Line,
 					pos.Col,

--- a/vendor/github.com/pingcap/parser/misc.go
+++ b/vendor/github.com/pingcap/parser/misc.go
@@ -234,6 +234,7 @@ var tokenMap = map[string]int{
 	"DELETE":                   deleteKwd,
 	"DESC":                     desc,
 	"DESCRIBE":                 describe,
+	"DIRECTORY":                directory,
 	"DISABLE":                  disable,
 	"DISTINCT":                 distinct,
 	"DISTINCTROW":              distinct,
@@ -289,6 +290,7 @@ var tokenMap = map[string]int{
 	"HASH":                     hash,
 	"HAVING":                   having,
 	"HIGH_PRIORITY":            highPriority,
+	"HISTORY":                  history,
 	"HOUR":                     hour,
 	"HOUR_MICROSECOND":         hourMicrosecond,
 	"HOUR_MINUTE":              hourMinute,
@@ -338,6 +340,7 @@ var tokenMap = map[string]int{
 	"LIMIT":                    limit,
 	"LINES":                    lines,
 	"LINEAR":                   linear,
+	"LIST":                     list,
 	"LOAD":                     load,
 	"LOCAL":                    local,
 	"LOCALTIME":                localTime,
@@ -380,6 +383,7 @@ var tokenMap = map[string]int{
 	"NO_WRITE_TO_BINLOG":       noWriteToBinLog,
 	"NODE_ID":                  nodeID,
 	"NODE_STATE":               nodeState,
+	"NODEGROUP":                nodegroup,
 	"NONE":                     none,
 	"NOT":                      not,
 	"NOW":                      now,
@@ -429,6 +433,7 @@ var tokenMap = map[string]int{
 	"REDUNDANT":                redundant,
 	"REFERENCES":               references,
 	"REGEXP":                   regexpKwd,
+	"REGIONS":                  regions,
 	"RELOAD":                   reload,
 	"RENAME":                   rename,
 	"REPEAT":                   repeat,
@@ -469,9 +474,12 @@ var tokenMap = map[string]int{
 	"SOME":                     some,
 	"SPLIT":                    split,
 	"SQL":                      sql,
+	"SQL_BIG_RESULT":           sqlBigResult,
+	"SQL_BUFFER_RESULT":        sqlBufferResult,
 	"SQL_CACHE":                sqlCache,
 	"SQL_CALC_FOUND_ROWS":      sqlCalcFoundRows,
 	"SQL_NO_CACHE":             sqlNoCache,
+	"SQL_SMALL_RESULT":         sqlSmallResult,
 	"SOURCE":                   source,
 	"SSL":                      ssl,
 	"START":                    start,
@@ -485,6 +493,7 @@ var tokenMap = map[string]int{
 	"STATUS":                   status,
 	"SWAPS":                    swaps,
 	"SWITCHES":                 switchesSym,
+	"SYSTEM_TIME":              systemTime,
 	"OPEN":                     open,
 	"STD":                      stddevPop,
 	"STDDEV":                   stddevPop,
@@ -579,6 +588,7 @@ var tokenMap = map[string]int{
 	"ZEROFILL":                 zerofill,
 	"BINDING":                  binding,
 	"BINDINGS":                 bindings,
+	"EXPR_PUSHDOWN_BLACKLIST":  exprPushdownBlacklist,
 }

 // See https://dev.mysql.com/doc/refman/5.7/en/function-resolution.html for details

--- a/vendor/github.com/pingcap/parser/model/ddl.go
+++ b/vendor/github.com/pingcap/parser/model/ddl.go
@@ -56,6 +56,8 @@ const (
 	ActionDropView                      ActionType = 24
 	ActionRecoverTable                  ActionType = 25
 	ActionModifySchemaCharsetAndCollate ActionType = 26
+	ActionLockTable                     ActionType = 27
+	ActionUnlockTable                   ActionType = 28
 )

 // AddIndexStr is a string related to the operation of "add index".
@@ -88,6 +90,8 @@ var actionMap = map[ActionType]string{
 	ActionDropView:                      "drop view",
 	ActionRecoverTable:                  "recover table",
 	ActionModifySchemaCharsetAndCollate: "modify schema charset and collate",
+	ActionLockTable:                     "lock table",
+	ActionUnlockTable:                   "unlock table",
 }

 // String return current ddl action in string

--- a/vendor/github.com/pingcap/parser/model/flags.go
+++ b/vendor/github.com/pingcap/parser/model/flags.go
@@ -40,4 +40,6 @@ const (
 	FlagIgnoreZeroInDate = 1 << 7
 	// FlagDividedByZeroAsWarning indicates if DividedByZero should be returned as warning.
 	FlagDividedByZeroAsWarning = 1 << 8
+	// FlagInUnionStmt indicates if this is a UNION statement.
+	FlagInUnionStmt = 1 << 9
 )
--- a/vendor/github.com/pingcap/parser/model/model.go
+++ b/vendor/github.com/pingcap/parser/model/model.go
@@ -15,6 +15,7 @@ package model

 import (
 	"encoding/json"
+	"strconv"
 	"strings"
 	"time"

@@ -230,11 +231,98 @@ type TableInfo struct {
 	Compression string `json:"compression"`

 	View *ViewInfo `json:"view"`
+	// Lock represent the table lock info.
+	Lock *TableLockInfo `json:"Lock"`

 	// Version means the version of the table info.
 	Version uint16 `json:"version"`
 }

+// TableLockInfo provides meta data describing a table lock.
+type TableLockInfo struct {
+	Tp TableLockType
+	// Use array because there may be multiple sessions holding the same read lock.
+	Sessions []SessionInfo
+	State    TableLockState
+	// TS is used to record the timestamp this table lock been locked.
+	TS uint64
+}
+
+// SessionInfo contain the session ID and the server ID.
+type SessionInfo struct {
+	ServerID  string
+	SessionID uint64
+}
+
+func (s SessionInfo) String() string {
+	return "server: " + s.ServerID + "_session: " + strconv.FormatUint(s.SessionID, 10)
+}
+
+// TableLockTpInfo is composed by schema ID, table ID and table lock type.
+type TableLockTpInfo struct {
+	SchemaID int64
+	TableID  int64
+	Tp       TableLockType
+}
+
+// TableLockState is the state for table lock.
+type TableLockState byte
+
+const (
+	// TableLockStateNone means this table lock is absent.
+	TableLockStateNone TableLockState = iota
+	// TableLockStatePreLock means this table lock is pre-lock state. Other session doesn't hold this lock should't do corresponding operation according to the lock type.
+	TableLockStatePreLock
+	// TableLockStatePublic means this table lock is public state.
+	TableLockStatePublic
+)
+
+// String implements fmt.Stringer interface.
+func (t TableLockState) String() string {
+	switch t {
+	case TableLockStatePreLock:
+		return "pre-lock"
+	case TableLockStatePublic:
+		return "public"
+	default:
+		return "none"
+	}
+}
+
+// TableLockType is the type of the table lock.
+type TableLockType byte
+
+const (
+	TableLockNone TableLockType = iota
+	// TableLockRead means the session with this lock can read the table (but not write it).
+	// Multiple sessions can acquire a READ lock for the table at the same time.
+	// Other sessions can read the table without explicitly acquiring a READ lock.
+	TableLockRead
+	// TableLockReadLocal is not supported.
+	TableLockReadLocal
+	// TableLockWrite means only the session with this lock has write/read permission.
+	// Only the session that holds the lock can access the table. No other session can access it until the lock is released.
+	TableLockWrite
+	// TableLockWriteLocal means the session with this lock has write/read permission, and the other session still has read permission.
+	TableLockWriteLocal
+)
+
+func (t TableLockType) String() string {
+	switch t {
+	case TableLockNone:
+		return "NONE"
+	case TableLockRead:
+		return "READ"
+	case TableLockReadLocal:
+		return "READ LOCAL"
+	case TableLockWriteLocal:
+		return "WRITE LOCAL"
+	case TableLockWrite:
+		return "WRITE"
+	}
+	return ""
+}
+
 // GetPartitionInfo returns the partition information.
 func (t *TableInfo) GetPartitionInfo() *PartitionInfo {
 	if t.Partition != nil && t.Partition.Enable {
@@ -345,6 +433,11 @@ func (t *TableInfo) FindIndexByName(idxName string) *IndexInfo {
 	return nil
 }

+// IsLocked checks whether the table was locked.
+func (t *TableInfo) IsLocked() bool {
+	return t.Lock != nil && len(t.Lock.Sessions) > 0
+}
+
 // NewExtraHandleColInfo mocks a column info for extra handle column.
 func NewExtraHandleColInfo() *ColumnInfo {
 	colInfo := &ColumnInfo{
@@ -452,9 +545,11 @@ type PartitionType int

 // Partition types.
 const (
-	PartitionTypeRange PartitionType = 1
-	PartitionTypeHash  PartitionType = 2
-	PartitionTypeList  PartitionType = 3
+	PartitionTypeRange      PartitionType = 1
+	PartitionTypeHash                     = 2
+	PartitionTypeList                     = 3
+	PartitionTypeKey                      = 4
+	PartitionTypeSystemTime               = 5
 )

 func (p PartitionType) String() string {
@@ -465,6 +560,10 @@ func (p PartitionType) String() string {
 		return "HASH"
 	case PartitionTypeList:
 		return "LIST"
+	case PartitionTypeKey:
+		return "KEY"
+	case PartitionTypeSystemTime:
+		return "SYSTEM_TIME"
 	default:
 		return ""
 	}

--- a/vendor/github.com/pingcap/parser/mysql/errcode.go
+++ b/vendor/github.com/pingcap/parser/mysql/errcode.go
@@ -882,6 +882,7 @@ const (
 	ErrMustChangePasswordLogin                                      = 1862
 	ErrRowInWrongPartition                                          = 1863
 	ErrErrorLast                                                    = 1863
+	ErrMaxExecTimeExceeded                                          = 1907
 	ErrInvalidJSONData                                              = 3069
 	ErrGeneratedColumnFunctionIsNotAllowed                          = 3102
 	ErrBadGeneratedColumn                                           = 3105
@@ -895,6 +896,7 @@ const (
 	ErrInvalidJSONPathWildcard                                      = 3149
 	ErrInvalidJSONContainsPathType                                  = 3150
 	ErrJSONUsedAsKey                                                = 3152
+	ErrInvalidJSONPathArrayCell                                     = 3165
 	ErrBadUser                                                      = 3162
 	ErrRoleNotGranted                                               = 3530
 	ErrWindowNoSuchWindow                                           = 3579
@@ -919,6 +921,11 @@ const (
 	ErrWindowExplainJson                                            = 3598
 	ErrWindowFunctionIgnoresFrame                                   = 3599

+	// MariaDB errors.
+	ErrOnlyOneDefaultPartionAllowed         = 4030
+	ErrWrongPartitionTypeExpectedSystemTime = 4113
+	ErrSystemVersioningWrongPartitions      = 4128
+
 	// TiDB self-defined errors.
 	ErrMemExceedThreshold         = 8001
 	ErrForUpdateCantRetry         = 8002
@@ -934,6 +941,7 @@ const (
 	ErrRequireVersionCheckFail    = 8107
 	ErrUnsupportedReloadPlugin    = 8018
 	ErrUnsupportedReloadPluginVar = 8019
+	ErrTableLocked                = 8020

 	// TiKV/PD errors.
 	ErrPDServerTimeout    = 9001

--- a/vendor/github.com/pingcap/parser/mysql/errname.go
+++ b/vendor/github.com/pingcap/parser/mysql/errname.go
@@ -892,6 +892,7 @@ var MySQLErrName = map[uint16]string{
 	ErrInvalidJSONPathWildcard:                               "In this situation, path expressions may not contain the * and ** tokens.",
 	ErrInvalidJSONContainsPathType:                           "The second argument can only be either 'one' or 'all'.",
 	ErrJSONUsedAsKey:                                         "JSON column '%-.192s' cannot be used in key specification.",
+	ErrInvalidJSONPathArrayCell:                              "A path expression is not a path to a cell in an array.",
 	ErrWindowNoSuchWindow:                                    "Window name '%s' is not defined.",
 	ErrWindowCircularityInWindowGraph:                        "There is a circularity in the window dependency graph.",
 	ErrWindowNoChildPartitioning:                             "A window which depends on another cannot define partitioning.",
@@ -914,6 +915,12 @@ var MySQLErrName = map[uint16]string{
 	ErrWindowExplainJson:                                     "To get information about window functions use EXPLAIN FORMAT=JSON",
 	ErrWindowFunctionIgnoresFrame:                            "Window function '%s' ignores the frame clause of window '%s' and aggregates over the whole partition",
 	ErrRoleNotGranted:                                        "%s is is not granted to %s",
+	ErrMaxExecTimeExceeded:                                   "Query execution was interrupted, max_execution_time exceeded.",
+
+	// MariaDB errors.
+	ErrOnlyOneDefaultPartionAllowed:         "Only one DEFAULT partition allowed",
+	ErrWrongPartitionTypeExpectedSystemTime: "Wrong partitioning type, expected type: `SYSTEM_TIME`",
+	ErrSystemVersioningWrongPartitions:      "Wrong Partitions: must have at least one HISTORY and exactly one last CURRENT",

 	// TiDB errors.
 	ErrMemExceedThreshold:         "%s holds %dB memory, exceeds threshold %dB.%s",
@@ -930,6 +937,7 @@ var MySQLErrName = map[uint16]string{
 	ErrRequireVersionCheckFail:    "Plugin %s require %s be %v but got %v",
 	ErrUnsupportedReloadPlugin:    "Plugin %s isn't loaded so cannot be reloaded",
 	ErrUnsupportedReloadPluginVar: "Reload plugin with different sysVar is unsupported %v",
+	ErrTableLocked:                "Table '%s' was locked in %s by %v",

 	// TiKV/PD errors.
 	ErrPDServerTimeout:    "PD server timeout",

--- a/vendor/github.com/pingcap/parser/parser.go
+++ b/vendor/github.com/pingcap/parser/parser.go
--- a/vendor/github.com/pingcap/parser/parser.y
+++ b/vendor/github.com/pingcap/parser/parser.y
@@ -227,8 +227,10 @@ import (
 	show			"SHOW"
 	smallIntType		"SMALLINT"
 	sql			"SQL"
+	sqlBigResult		"SQL_BIG_RESULT"
 	sqlCalcFoundRows	"SQL_CALC_FOUND_ROWS"
-	ssl	            	"SSL"
+	sqlSmallResult		"SQL_SMALL_RESULT"
+	ssl			"SSL"
 	starting		"STARTING"
 	straightJoin		"STRAIGHT_JOIN"
 	tableKwd		"TABLE"
@@ -314,6 +316,7 @@ import (
 	deallocate	"DEALLOCATE"
 	definer		"DEFINER"
 	delayKeyWrite	"DELAY_KEY_WRITE"
+	directory	"DIRECTORY"
 	disable		"DISABLE"
 	do		"DO"
 	duplicate	"DUPLICATE"
@@ -340,6 +343,7 @@ import (
 	function	"FUNCTION"
 	grants		"GRANTS"
 	hash		"HASH"
+	history		"HISTORY"
 	hour		"HOUR"
 	identified	"IDENTIFIED"
 	isolation	"ISOLATION"
@@ -355,6 +359,7 @@ import (
 	last		"LAST"
 	less		"LESS"
 	level		"LEVEL"
+	list		"LIST"
 	master		"MASTER"
 	microsecond	"MICROSECOND"
 	minute		"MINUTE"
@@ -373,6 +378,7 @@ import (
 	national	"NATIONAL"
 	never		"NEVER"
 	no		"NO"
+	nodegroup	"NODEGROUP"
 	none		"NONE"
 	nulls		"NULLS"
 	offset		"OFFSET"
@@ -416,6 +422,7 @@ import (
 	slave		"SLAVE"
 	slow		"SLOW"
 	snapshot	"SNAPSHOT"
+	sqlBufferResult	"SQL_BUFFER_RESULT"
 	sqlCache	"SQL_CACHE"
 	sqlNoCache	"SQL_NO_CACHE"
 	start		"START"
@@ -423,6 +430,7 @@ import (
 	status		"STATUS"
 	swaps		"SWAPS"
 	switchesSym	"SWITCHES"
+	systemTime	"SYSTEM_TIME"
 	open		"OPEN"
 	source	   	"SOURCE"
 	subject		"SUBJECT"
@@ -506,6 +514,7 @@ import (
 	variance		"VARIANCE"
 	varPop			"VAR_POP"
 	varSamp			"VAR_SAMP"
+	exprPushdownBlacklist		"EXPR_PUSHDOWN_BLACKLIST"

 	/* The following tokens belong to TiDBKeyword. Notice: make sure these tokens are contained in TiDBKeyword. */
 	admin		"ADMIN"
@@ -530,6 +539,7 @@ import (
 	tidbSMJ		"TIDB_SMJ"
 	tidbINLJ	"TIDB_INLJ"
 	split		"SPLIT"
+	regions         "REGIONS"

 	builtinAddDate
 	builtinBitAnd
@@ -654,7 +664,7 @@ import (
 	RevokeStmt			"Revoke statement"
 	RevokeRoleStmt      "Revoke role statement"
 	RollbackStmt			"ROLLBACK statement"
-	SplitIndexRegionStmt		"Split index region statement"
+	SplitRegionStmt		"Split index region statement"
 	SetStmt				"Set variable statement"
 	ChangeStmt				"Change statement"
 	SetRoleStmt				"Set active role statement"
@@ -672,9 +682,9 @@ import (
 %type   <item>
 	AdminShowSlow			"Admin Show Slow statement"
 	AlterAlgorithm			"Alter table algorithm"
-	AlterTableOptionListOpt		"Alter table option list opt"
 	AlterTableSpec			"Alter table specification"
 	AlterTableSpecList		"Alter table specification list"
+	AlterTableSpecListOpt		"Alter table specification list optional"
 	AnyOrAll			"Any or All for subquery"
 	Assignment			"assignment"
 	AssignmentList			"assignment list"
@@ -794,12 +804,13 @@ import (
 	PartitionDefinition		"Partition definition"
 	PartitionDefinitionList 	"Partition definition list"
 	PartitionDefinitionListOpt	"Partition definition list option"
+	PartitionKeyAlgorithmOpt	"ALGORITHM = n option for KEY partition"
+	PartitionMethod			"Partition method"
 	PartitionOpt			"Partition option"
 	PartitionNameList		"Partition name list"
 	PartitionNameListOpt    "table partition names list optional"
 	PartitionNumOpt			"PARTITION NUM option"
 	PartDefValuesOpt		"VALUES {LESS THAN {(expr | value_list) | MAXVALUE} | IN {value_list}"
-	PartDefOptionsOpt		"PartDefOptionList option"
 	PartDefOptionList		"PartDefOption list"
 	PartDefOption			"COMMENT [=] xxx | TABLESPACE [=] tablespace_name | ENGINE [=] xxx"
 	PasswordExpire			"Single password option for create user statement"
@@ -830,7 +841,10 @@ import (
 	RowValue			"Row value"
 	SelectLockOpt			"FOR UPDATE or LOCK IN SHARE MODE,"
 	SelectStmtCalcFoundRows		"SELECT statement optional SQL_CALC_FOUND_ROWS"
+	SelectStmtSQLBigResult		"SELECT statement optional SQL_BIG_RESULT"
+	SelectStmtSQLBufferResult	"SELECT statement optional SQL_BUFFER_RESULT"
 	SelectStmtSQLCache		"SELECT statement optional SQL_CAHCE/SQL_NO_CACHE"
+	SelectStmtSQLSmallResult	"SELECT statement optional SQL_SMALL_RESULT"
 	SelectStmtStraightJoin		"SELECT statement optional STRAIGHT_JOIN"
 	SelectStmtFieldList		"SELECT statement field list"
 	SelectStmtLimit			"SELECT statement optional LIMIT clause"
@@ -849,11 +863,16 @@ import (
 	ShowProfileTypesOpt		"Show profile types option"
 	ShowProfileType			"Show profile type"
 	ShowProfileTypes		"Show profile types"
+	SplitOption			"Split Option"
 	Starting			"Starting by"
 	StatementList			"statement list"
 	StatsPersistentVal		"stats_persistent value"
 	StringName			"string literal or identifier"
 	StringList 			"string list"
+	SubPartDefinition		"SubPartition definition"
+	SubPartDefinitionList		"SubPartition definition list"
+	SubPartDefinitionListOpt	"SubPartition definition list optional"
+	SubPartitionMethod		"SubPartition method"
 	SubPartitionOpt			"SubPartition option"
 	SubPartitionNumOpt		"SubPartition NUM option"
 	Symbol				"Constraint Symbol"
@@ -874,6 +893,7 @@ import (
 	TableRefs 			"table references"
 	TableToTable 			"rename table to table"
 	TableToTableList 		"rename table to table by list"
+	LockType			"Table locks type"

 	TransactionChar		"Transaction characteristic"
 	TransactionChars	"Transaction characteristic list"
@@ -996,7 +1016,6 @@ import (
 	NationalOpt		"National option"
 	CharsetKw		"charset or charater set"
 	CommaOpt		"optional comma"
-	LockType		"Table locks type"
 	logAnd			"logical and operator"
 	logOr			"logical or operator"
 	LinearOpt		"linear or empty"
@@ -1017,6 +1036,9 @@ import (

 %precedence empty

+%precedence sqlBufferResult
+%precedence sqlBigResult
+%precedence sqlSmallResult
 %precedence sqlCache sqlNoCache
 %precedence lowerThanIntervalKeyword
 %precedence interval
@@ -1055,6 +1077,7 @@ import (
 %right 	not not2
 %right	collate

+%left splitOptionPriv
 %precedence '('
 %precedence quick
 %precedence escape
@@ -1073,11 +1096,18 @@ Start:
 * See https://dev.mysql.com/doc/refman/5.7/en/alter-table.html
 *******************************************************************************************/
 AlterTableStmt:
-	"ALTER" IgnoreOptional "TABLE" TableName AlterTableSpecList
+	"ALTER" IgnoreOptional "TABLE" TableName AlterTableSpecListOpt PartitionOpt
 	{
+		specs := $5.([]*ast.AlterTableSpec)
+		if $6 != nil {
+			specs = append(specs, &ast.AlterTableSpec{
+				Tp:        ast.AlterTablePartition,
+				Partition: $6.(*ast.PartitionOptions),
+			})
+		}
 		$$ = &ast.AlterTableStmt{
 			Table: $4.(*ast.TableName),
-			Specs: $5.([]*ast.AlterTableSpec),
+			Specs: specs,
 		}
 	}
 |	"ALTER" IgnoreOptional "TABLE" TableName "ANALYZE" "PARTITION" PartitionNameList MaxNumBuckets
@@ -1096,7 +1126,7 @@ AlterTableStmt:
 	}

 AlterTableSpec:
-	AlterTableOptionListOpt
+	TableOptionList %prec higherThanComma
 	{
 		$$ = &ast.AlterTableSpec{
 			Tp:	ast.AlterTableOption,
@@ -1173,18 +1203,18 @@ AlterTableSpec:
 	{
 		$$ = &ast.AlterTableSpec{Tp: ast.AlterTableDropPrimaryKey}
 	}
-|	"DROP" "PARTITION" Identifier
+|	"DROP" "PARTITION" PartitionNameList %prec lowerThanComma
 	{
 		$$ = &ast.AlterTableSpec{
 			Tp: ast.AlterTableDropPartition,
-			Name: $3,
+			PartitionNames: $3.([]model.CIStr),
 		}
 	}
-|	"TRUNCATE" "PARTITION" Identifier
+|	"TRUNCATE" "PARTITION" PartitionNameList %prec lowerThanComma
 	{
 		$$ = &ast.AlterTableSpec{
 			Tp: ast.AlterTableTruncatePartition,
-			Name: $3,
+			PartitionNames: $3.([]model.CIStr),
 		}
 	}
 |	"DROP" KeyOrIndex Identifier
@@ -1203,11 +1233,15 @@ AlterTableSpec:
 	}
 |	"DISABLE" "KEYS"
 	{
-		$$ = &ast.AlterTableSpec{}
+		$$ = &ast.AlterTableSpec{
+			Tp: ast.AlterTableDisableKeys,
+		}
 	}
 |	"ENABLE" "KEYS"
 	{
-		$$ = &ast.AlterTableSpec{}
+		$$ = &ast.AlterTableSpec{
+			Tp: ast.AlterTableEnableKeys,
+		}
 	}
 |	"MODIFY" ColumnKeywordOpt ColumnDef ColumnPosition
 	{
@@ -1369,6 +1403,16 @@ ColumnPosition:
 		}
 	}

+AlterTableSpecListOpt:
+	/* empty */
+	{
+		$$ = make([]*ast.AlterTableSpec, 0, 1)
+	}
+|	AlterTableSpecList
+	{
+		$$ = $1
+	}
+
 AlterTableSpecList:
 	AlterTableSpec
 	{
@@ -1480,13 +1524,37 @@ RecoverTableStmt:
 *      SPLIT TABLE table_name INDEX index_name BY (val1...),(val2...)...
 *
 *******************************************************************/
-SplitIndexRegionStmt:
-	"SPLIT" "TABLE" TableName "INDEX" IndexName "BY" ValuesList
+SplitRegionStmt:
+	"SPLIT" "TABLE" TableName SplitOption
 	{
-		$$ = &ast.SplitIndexRegionStmt{
+		$$ = &ast.SplitRegionStmt{
 			Table: $3.(*ast.TableName),
-			IndexName: $5.(string),
-			ValueLists: $7.([][]ast.ExprNode),
+			SplitOpt: $4.(*ast.SplitOption),
+		}
+	}
+|	"SPLIT" "TABLE" TableName "INDEX" Identifier SplitOption
+	{
+		$$ = &ast.SplitRegionStmt{
+			Table: $3.(*ast.TableName),
+			IndexName: model.NewCIStr($5),
+			SplitOpt: $6.(*ast.SplitOption),
+		}
+	}
+
+
+SplitOption:
+	"BETWEEN" RowValue "AND" RowValue "REGIONS" NUM
+	{
+		$$ = &ast.SplitOption{
+			Lower: $2.([]ast.ExprNode),
+			Upper: $4.([]ast.ExprNode),
+			Num: $6.(int64),
+		}
+	}
+|	"BY" ValuesList
+	{
+		$$ = &ast.SplitOption{
+			ValueLists: $2.([][]ast.ExprNode),
 		}
 	}

@@ -2178,50 +2246,100 @@ PartitionOpt:
 	{
 		$$ = nil
 	}
-|	"PARTITION" "BY" "KEY" '(' ColumnNameList ')' PartitionNumOpt PartitionDefinitionListOpt
+|	"PARTITION" "BY" PartitionMethod PartitionNumOpt SubPartitionOpt PartitionDefinitionListOpt
 	{
-		$$ = nil
+		method := $3.(*ast.PartitionMethod)
+		method.Num = $4.(uint64)
+		sub, _ := $5.(*ast.PartitionMethod)
+		defs, _ := $6.([]*ast.PartitionDefinition)
+		opt := &ast.PartitionOptions{
+			PartitionMethod: *method,
+			Sub:             sub,
+			Definitions:     defs,
+		}
+		if err := opt.Validate(); err != nil {
+			yylex.AppendError(err)
+			return 1
+		}
+		$$ = opt
 	}
-|	"PARTITION" "BY" LinearOpt "HASH" '(' Expression ')' PartitionNumOpt
+
+SubPartitionMethod:
+	LinearOpt "KEY" PartitionKeyAlgorithmOpt '(' ColumnNameListOpt ')'
 	{
-		tmp := &ast.PartitionOptions{
-			Tp: model.PartitionTypeHash,
-			Expr: $6.(ast.ExprNode),
-			// If you do not include a PARTITIONS clause, the number of partitions defaults to 1
-			Num: 1,
+		$$ = &ast.PartitionMethod{
+			Tp:          model.PartitionTypeKey,
+			Linear:      len($1) != 0,
+			ColumnNames: $5.([]*ast.ColumnName),
 		}
-		if $8 != nil {
-			tmp.Num = getUint64FromNUM($8)
+	}
+|	LinearOpt "HASH" '(' Expression ')'
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:     model.PartitionTypeHash,
+			Linear: len($1) != 0,
+			Expr:   $4.(ast.ExprNode),
 		}
-		if $3 != "" {
-			yylex.Errorf("linear is not supported, ignore partition")
-			parser.lastErrorAsWarn()
-			tmp = nil
+	}
+
+PartitionKeyAlgorithmOpt:
+	/* empty */
+	{}
+|	"ALGORITHM" '=' NUM
+	{}
+
+PartitionMethod:
+	SubPartitionMethod
+	{
+		$$ = $1
+	}
+|	"RANGE" '(' Expression ')'
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:   model.PartitionTypeRange,
+			Expr: $3.(ast.ExprNode),
 		}
-		$$ = tmp
 	}
-|	"PARTITION" "BY" "RANGE" '(' Expression ')' PartitionNumOpt SubPartitionOpt PartitionDefinitionListOpt
+|	"RANGE" "COLUMNS" '(' ColumnNameList ')'
 	{
-		var defs []*ast.PartitionDefinition
-		if $9 != nil {
-			defs = $9.([]*ast.PartitionDefinition)
+		$$ = &ast.PartitionMethod{
+			Tp:          model.PartitionTypeRange,
+			ColumnNames: $4.([]*ast.ColumnName),
 		}
-		$$ = &ast.PartitionOptions{
-			Tp:		model.PartitionTypeRange,
-			Expr:		$5.(ast.ExprNode),
-			Definitions:	defs,
+	}
+|	"LIST" '(' Expression ')'
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:   model.PartitionTypeList,
+			Expr: $3.(ast.ExprNode),
 		}
 	}
-|	"PARTITION" "BY" "RANGE" "COLUMNS" '(' ColumnNameList ')' PartitionNumOpt SubPartitionOpt PartitionDefinitionListOpt
+|	"LIST" "COLUMNS" '(' ColumnNameList ')'
 	{
-		var defs []*ast.PartitionDefinition
-		if $10 != nil {
-			defs = $10.([]*ast.PartitionDefinition)
+		$$ = &ast.PartitionMethod{
+			Tp:          model.PartitionTypeList,
+			ColumnNames: $4.([]*ast.ColumnName),
+		}
+	}
+|	"SYSTEM_TIME" "INTERVAL" Expression TimeUnit
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:    model.PartitionTypeSystemTime,
+			Expr:  $3.(ast.ExprNode),
+			Unit:  ast.NewValueExpr($4),
 		}
-		$$ = &ast.PartitionOptions{
-			Tp:		model.PartitionTypeRange,
-			ColumnNames:	$6.([]*ast.ColumnName),
-			Definitions:	defs,
+	}
+|	"SYSTEM_TIME" "LIMIT" LengthNum
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:    model.PartitionTypeSystemTime,
+			Limit: $3.(uint64),
+		}
+	}
+|	"SYSTEM_TIME"
+	{
+		$$ = &ast.PartitionMethod{
+			Tp:    model.PartitionTypeSystemTime,
 		}
 	}

@@ -2235,24 +2353,42 @@ LinearOpt:
 	}

 SubPartitionOpt:
-	{}
-|	"SUBPARTITION" "BY" "HASH" '(' Expression ')' SubPartitionNumOpt
-	{}
-|	"SUBPARTITION" "BY" "KEY" '(' ColumnNameList ')' SubPartitionNumOpt
-	{}
+	{
+		$$ = nil
+	}
+|	"SUBPARTITION" "BY" SubPartitionMethod SubPartitionNumOpt
+	{
+		method := $3.(*ast.PartitionMethod)
+		method.Num = $4.(uint64)
+		$$ = method
+	}

 SubPartitionNumOpt:
-	{}
-|	"SUBPARTITIONS" NUM
-	{}
+	{
+		$$ = uint64(0)
+	}
+|	"SUBPARTITIONS" LengthNum
+	{
+		res := $2.(uint64)
+		if res == 0 {
+			yylex.AppendError(ast.ErrNoParts.GenWithStackByArgs("subpartitions"))
+			return 1
+		}
+		$$ = res
+	}

 PartitionNumOpt:
 	{
-		$$ = nil
+		$$ = uint64(0)
 	}
-|	"PARTITIONS" NUM
+|	"PARTITIONS" LengthNum
 	{
-		$$ = $2
+		res := $2.(uint64)
+		if res == 0 {
+			yylex.AppendError(ast.ErrNoParts.GenWithStackByArgs("partitions"))
+			return 1
+		}
+		$$ = res
 	}

 PartitionDefinitionListOpt:
@@ -2276,74 +2412,131 @@ PartitionDefinitionList:
 	}

 PartitionDefinition:
-	"PARTITION" Identifier PartDefValuesOpt PartDefOptionsOpt
+	"PARTITION" Identifier PartDefValuesOpt PartDefOptionList SubPartDefinitionListOpt
 	{
-		partDef := &ast.PartitionDefinition{
-			Name: model.NewCIStr($2),
-		}
-		switch $3.(type) {
-		case []ast.ExprNode:
-			partDef.LessThan = $3.([]ast.ExprNode)
-		case ast.ExprNode:
-			partDef.LessThan = make([]ast.ExprNode, 1)
-			partDef.LessThan[0] = $3.(ast.ExprNode)
+		$$ = &ast.PartitionDefinition{
+			Name:    model.NewCIStr($2),
+			Clause:  $3.(ast.PartitionDefinitionClause),
+			Options: $4.([]*ast.TableOption),
+			Sub:     $5.([]*ast.SubPartitionDefinition),
 		}
+	}

-		if comment, ok := $4.(string); ok {
-			partDef.Comment = comment
-		}
-		$$ = partDef
+SubPartDefinitionListOpt:
+	/*empty*/
+	{
+		$$ = make([]*ast.SubPartitionDefinition, 0)
+	}
+|	'(' SubPartDefinitionList ')'
+	{
+		$$ = $2
 	}

-PartDefOptionsOpt:
+SubPartDefinitionList:
+	SubPartDefinition
 	{
-		$$ = nil
+		$$ = []*ast.SubPartitionDefinition{$1.(*ast.SubPartitionDefinition)}
 	}
-|	PartDefOptionList
+|	SubPartDefinitionList ',' SubPartDefinition
 	{
-		$$ = $1
+		list := $1.([]*ast.SubPartitionDefinition)
+		$$ = append(list, $3.(*ast.SubPartitionDefinition))
+	}
+
+SubPartDefinition:
+	"SUBPARTITION" Identifier PartDefOptionList
+	{
+		$$ = &ast.SubPartitionDefinition{
+			Name:    model.NewCIStr($2),
+			Options: $3.([]*ast.TableOption),
+		}
 	}

 PartDefOptionList:
-	PartDefOption
+	/*empty*/
 	{
-		$$ = $1
+		$$ = make([]*ast.TableOption, 0)
 	}
 |	PartDefOptionList PartDefOption
 	{
-		if $1 != nil {
-			$$ = $1
-		} else {
-			$$ = $2
-		}
+		list := $1.([]*ast.TableOption)
+		$$ = append(list, $2.(*ast.TableOption))
 	}

 PartDefOption:
 	"COMMENT" EqOpt stringLit
 	{
-		$$ = $3
+		$$ = &ast.TableOption{Tp: ast.TableOptionComment, StrValue: $3}
 	}
-|	"ENGINE" EqOpt Identifier
+|	"ENGINE" EqOpt StringName
 	{
-		$$ = nil
+		$$ = &ast.TableOption{Tp: ast.TableOptionEngine, StrValue: $3.(string)}
+	}
+|	"DATA" "DIRECTORY" EqOpt stringLit
+	{
+		$$ = &ast.TableOption{Tp: ast.TableOptionDataDirectory, StrValue: $4}
+	}
+|	"INDEX" "DIRECTORY" EqOpt stringLit
+	{
+		$$ = &ast.TableOption{Tp: ast.TableOptionIndexDirectory, StrValue: $4}
+	}
+|	"MAX_ROWS" EqOpt LengthNum
+	{
+		$$ = &ast.TableOption{Tp: ast.TableOptionMaxRows, UintValue: $3.(uint64)}
+	}
+|	"MIN_ROWS" EqOpt LengthNum
+	{
+		$$ = &ast.TableOption{Tp: ast.TableOptionMinRows, UintValue: $3.(uint64)}
 	}
 |	"TABLESPACE" EqOpt Identifier
 	{
-		$$ =  nil
+		$$ = &ast.TableOption{Tp: ast.TableOptionTablespace, StrValue: $3}
+	}
+|	"NODEGROUP" EqOpt LengthNum
+	{
+		$$ = &ast.TableOption{Tp: ast.TableOptionNodegroup, UintValue: $3.(uint64)}
 	}
-

 PartDefValuesOpt:
 	{
-		$$ = nil
+		$$ = &ast.PartitionDefinitionClauseNone{}
 	}
 |	"VALUES" "LESS" "THAN" "MAXVALUE"
 	{
-		$$ = &ast.MaxValueExpr{}
+		$$ = &ast.PartitionDefinitionClauseLessThan{
+			Exprs: []ast.ExprNode{&ast.MaxValueExpr{}},
+		}
 	}
 |	"VALUES" "LESS" "THAN" '(' MaxValueOrExpressionList ')'
 	{
-		$$ = $5
+		$$ = &ast.PartitionDefinitionClauseLessThan{
+			Exprs: $5.([]ast.ExprNode),
+		}
+	}
+|	"DEFAULT"
+	{
+		$$ = &ast.PartitionDefinitionClauseIn{}
+	}
+|	"VALUES" "IN" '(' ExpressionList ')'
+	{
+		exprs := $4.([]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})
+			}
+		}
+		$$ = &ast.PartitionDefinitionClauseIn{Values: values}
+	}
+|	"HISTORY"
+	{
+		$$ = &ast.PartitionDefinitionClauseHistory{Current: false}
+	}
+|	"CURRENT"
+	{
+		$$ = &ast.PartitionDefinitionClauseHistory{Current: true}
 	}

 DuplicateOpt:
@@ -3317,21 +3510,20 @@ UnReservedKeyword:
 | "NONE" | "NULLS" | "SUPER" | "EXCLUSIVE" | "STATS_PERSISTENT" | "ROW_COUNT" | "COALESCE" | "MONTH" | "PROCESS" | "PROFILE" | "PROFILES"
 | "MICROSECOND" | "MINUTE" | "PLUGINS" | "PRECEDING" | "QUERY" | "QUERIES" | "SECOND" | "SEPARATOR" | "SHARE" | "SHARED" | "SLOW" | "MAX_CONNECTIONS_PER_HOUR" | "MAX_QUERIES_PER_HOUR" | "MAX_UPDATES_PER_HOUR"
 | "MAX_USER_CONNECTIONS" | "REPLICATION" | "CLIENT" | "SLAVE" | "RELOAD" | "TEMPORARY" | "ROUTINE" | "EVENT" | "ALGORITHM" | "DEFINER" | "INVOKER" | "MERGE" | "TEMPTABLE" | "UNDEFINED" | "SECURITY" | "CASCADED"
-| "RECOVER" | "CIPHER" | "SUBJECT" | "ISSUER" | "X509" | "NEVER" | "EXPIRE" | "ACCOUNT" | "INCREMENTAL" | "CPU" | "MEMORY" | "BLOCK" | "IO" | "CONTEXT" | "SWITCHES" | "PAGE" | "FAULTS" | "IPC" | "SWAPS" | "SOURCE" | "TRADITIONAL"
-
-
-
+| "RECOVER" | "CIPHER" | "SUBJECT" | "ISSUER" | "X509" | "NEVER" | "EXPIRE" | "ACCOUNT" | "INCREMENTAL" | "CPU" | "MEMORY" | "BLOCK" | "IO" | "CONTEXT" | "SWITCHES" | "PAGE" | "FAULTS" | "IPC" | "SWAPS" | "SOURCE"
+| "TRADITIONAL" | "SQL_BUFFER_RESULT" | "DIRECTORY" | "HISTORY" | "LIST" | "NODEGROUP" | "SYSTEM_TIME"


 TiDBKeyword:
 "ADMIN" | "BUCKETS" | "CANCEL" | "DDL" | "DRAINER" | "JOBS" | "JOB" | "NODE_ID" | "NODE_STATE" | "PUMP" | "STATS" | "STATS_META" | "STATS_HISTOGRAMS" | "STATS_BUCKETS" | "STATS_HEALTHY" | "TIDB" | "TIDB_HJ"
-| "TIDB_SMJ" | "TIDB_INLJ" | "SPLIT" | "OPTIMISTIC" | "PESSIMISTIC"
+| "TIDB_SMJ" | "TIDB_INLJ" | "SPLIT" | "OPTIMISTIC" | "PESSIMISTIC" | "REGIONS"

 NotKeywordToken:
 "ADDDATE" | "BIT_AND" | "BIT_OR" | "BIT_XOR" | "CAST" | "COPY" | "COUNT" | "CURTIME" | "DATE_ADD" | "DATE_SUB" | "EXTRACT" | "GET_FORMAT" | "GROUP_CONCAT"
 | "INPLACE" | "INSTANT" | "INTERNAL" |"MIN" | "MAX" | "MAX_EXECUTION_TIME" | "NOW" | "RECENT" | "POSITION" | "SUBDATE" | "SUBSTRING" | "SUM"
 | "STD" | "STDDEV" | "STDDEV_POP" | "STDDEV_SAMP" | "VARIANCE" | "VAR_POP" | "VAR_SAMP"
 | "TIMESTAMPADD" | "TIMESTAMPDIFF" | "TOKUDB_DEFAULT" | "TOKUDB_FAST" | "TOKUDB_LZMA" | "TOKUDB_QUICKLZ" | "TOKUDB_SNAPPY" | "TOKUDB_SMALL" | "TOKUDB_UNCOMPRESSED" | "TOKUDB_ZLIB" | "TOP" | "TRIM" | "NEXT_ROW_ID"
+| "EXPR_PUSHDOWN_BLACKLIST"

 /************************************************************************************
 *
@@ -5503,7 +5695,7 @@ SelectStmtLimit:


 SelectStmtOpts:
-	TableOptimizerHints DefaultFalseDistinctOpt PriorityOpt SelectStmtSQLCache SelectStmtCalcFoundRows SelectStmtStraightJoin
+	TableOptimizerHints DefaultFalseDistinctOpt PriorityOpt SelectStmtSQLSmallResult SelectStmtSQLBigResult SelectStmtSQLBufferResult SelectStmtSQLCache SelectStmtCalcFoundRows SelectStmtStraightJoin
 	{
 		opt := &ast.SelectStmtOpts{}
 		if $1 != nil {
@@ -5516,13 +5708,22 @@ SelectStmtOpts:
 			opt.Priority = $3.(mysql.PriorityEnum)
 		}
 		if $4 != nil {
-			opt.SQLCache = $4.(bool)
+			opt.SQLSmallResult = $4.(bool)
 		}
 		if $5 != nil {
-			opt.CalcFoundRows = $5.(bool)
+			opt.SQLBigResult = $5.(bool)
 		}
 		if $6 != nil {
-			opt.StraightJoin = $6.(bool)
+			opt.SQLBufferResult = $6.(bool)
+		}
+		if $7 != nil {
+			opt.SQLCache = $7.(bool)
+		}
+		if $8 != nil {
+			opt.CalcFoundRows = $8.(bool)
+		}
+		if $9 != nil {
+			opt.StraightJoin = $9.(bool)
 		}

 		$$ = opt
@@ -5590,6 +5791,24 @@ SelectStmtCalcFoundRows:
 	{
 		$$ = true
 	}
+SelectStmtSQLBigResult:
+	%prec empty
+	{
+		$$ = false
+	}
+|	"SQL_BIG_RESULT"
+	{
+		$$ = true
+	}
+SelectStmtSQLBufferResult:
+	%prec empty
+	{
+		$$ = false
+	}
+|	"SQL_BUFFER_RESULT"
+	{
+		$$ = true
+	}
 SelectStmtSQLCache:
 	%prec empty
 	{
@@ -5603,6 +5822,15 @@ SelectStmtSQLCache:
 	{
 		$$ = false
 	}
+SelectStmtSQLSmallResult:
+	%prec empty
+	{
+		$$ = false
+	}
+|	"SQL_SMALL_RESULT"
+	{
+		$$ = true
+	}
 SelectStmtStraightJoin:
 	%prec empty
 	{
@@ -5954,24 +6182,27 @@ SetExpr:
 	}
 |	ExprOrDefault

+EqOrAssignmentEq:
+    eq | assignmentEq
+
 VariableAssignment:
-	Identifier eq SetExpr
+	Identifier EqOrAssignmentEq SetExpr
 	{
 		$$ = &ast.VariableAssignment{Name: $1, Value: $3, IsSystem: true}
 	}
-|	"GLOBAL" Identifier eq SetExpr
+|	"GLOBAL" Identifier EqOrAssignmentEq SetExpr
 	{
 		$$ = &ast.VariableAssignment{Name: $2, Value: $4, IsGlobal: true, IsSystem: true}
 	}
-|	"SESSION" Identifier eq SetExpr
+|	"SESSION" Identifier EqOrAssignmentEq SetExpr
 	{
 		$$ = &ast.VariableAssignment{Name: $2, Value: $4, IsSystem: true}
 	}
-|	"LOCAL" Identifier eq Expression
+|	"LOCAL" Identifier EqOrAssignmentEq Expression
 	{
 		$$ = &ast.VariableAssignment{Name: $2, Value: $4, IsSystem: true}
 	}
-|	doubleAtIdentifier eq SetExpr
+|	doubleAtIdentifier EqOrAssignmentEq SetExpr
 	{
 		v := strings.ToLower($1)
 		var isGlobal bool
@@ -5987,13 +6218,7 @@ VariableAssignment:
 		}
 		$$ = &ast.VariableAssignment{Name: v, Value: $3, IsGlobal: isGlobal, IsSystem: true}
 	}
-|	singleAtIdentifier eq Expression
-	{
-		v := $1
-		v = strings.TrimPrefix(v, "@")
-		$$ = &ast.VariableAssignment{Name: v, Value: $3}
-	}
-|	singleAtIdentifier assignmentEq Expression
+|	singleAtIdentifier EqOrAssignmentEq Expression
 	{
 		v := $1
 		v = strings.TrimPrefix(v, "@")
@@ -6272,6 +6497,12 @@ AdminStmt:
 			ShowSlow: $4.(*ast.ShowSlow),
 		}
 	}
+|	"ADMIN" "RELOAD" "EXPR_PUSHDOWN_BLACKLIST"
+ 	{
+ 		$$ = &ast.AdminStmt{
+ 			Tp: ast.AdminReloadExprPushdownBlacklist,
+ 		}
+ 	}

 AdminShowSlow:
 	"RECENT" NUM
@@ -6933,7 +7164,7 @@ Statement:
 |	SetStmt
 |	SetRoleStmt
 |	SetDefaultRoleStmt
-|	SplitIndexRegionStmt
+|	SplitRegionStmt
 |	ShowStmt
 |	SubSelect
 	{
@@ -7060,13 +7291,9 @@ TableElementListOpt:
 	}

 TableOption:
-	"ENGINE" StringName
-	{
-		$$ = &ast.TableOption{Tp: ast.TableOptionEngine, StrValue: $2.(string)}
-	}
-|	"ENGINE" eq StringName
+	PartDefOption
 	{
-		$$ = &ast.TableOption{Tp: ast.TableOptionEngine, StrValue: $3.(string)}
+		$$ = $1
 	}
 |	DefaultKwdOpt CharsetKw EqOpt CharsetName
 	{
@@ -7080,10 +7307,6 @@ TableOption:
 	{
 		$$ = &ast.TableOption{Tp: ast.TableOptionAutoIncrement, UintValue: $3.(uint64)}
 	}
-|	"COMMENT" EqOpt stringLit
-	{
-		$$ = &ast.TableOption{Tp: ast.TableOptionComment, StrValue: $3}
-	}
 |	"AVG_ROW_LENGTH" EqOpt LengthNum
 	{
 		$$ = &ast.TableOption{Tp: ast.TableOptionAvgRowLength, UintValue: $3.(uint64)}
@@ -7108,14 +7331,6 @@ TableOption:
 	{
 		$$ = &ast.TableOption{Tp: ast.TableOptionKeyBlockSize, UintValue: $3.(uint64)}
 	}
-|	"MAX_ROWS" EqOpt LengthNum
-	{
-		$$ = &ast.TableOption{Tp: ast.TableOptionMaxRows, UintValue: $3.(uint64)}
-	}
-|	"MIN_ROWS" EqOpt LengthNum
-	{
-		$$ = &ast.TableOption{Tp: ast.TableOptionMinRows, UintValue: $3.(uint64)}
-	}
 |	"DELAY_KEY_WRITE" EqOpt LengthNum
 	{
 		$$ = &ast.TableOption{Tp: ast.TableOptionDelayKeyWrite, UintValue: $3.(uint64)}
@@ -7148,12 +7363,6 @@ StatsPersistentVal:
 |	LengthNum
 	{}

-AlterTableOptionListOpt:
-	{
-		$$ = []*ast.TableOption{}
-	}
-|	TableOptionList %prec higherThanComma
-
 CreateTableOptionListOpt:
 	/* empty */ %prec lowerThanCreateTableSelect
 	{
@@ -7310,10 +7519,11 @@ NumericType:
 		fopt := $2.(*ast.FloatOpt)
 		x := types.NewFieldType($1.(byte))
 		x.Flen = fopt.Flen
-		if x.Tp == mysql.TypeFloat {
+		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 $3.([]*ast.TypeOpt) {
@@ -8724,11 +8934,18 @@ LoadDataSetItem:
 *********************************************************************/

 UnlockTablesStmt:
-	"UNLOCK" TablesTerminalSym {}
+	"UNLOCK" TablesTerminalSym
+	{
+		$$ = &ast.UnlockTablesStmt{}
+	}

 LockTablesStmt:
 	"LOCK" TablesTerminalSym TableLockList
-	{}
+        {
+		$$ = &ast.LockTablesStmt{
+			TableLocks: $3.([]ast.TableLock),
+		}
+        }

 TablesTerminalSym:
 	"TABLES"
@@ -8736,15 +8953,40 @@ TablesTerminalSym:

 TableLock:
 	TableName LockType
+        {
+		$$ = ast.TableLock{
+			Table: $1.(*ast.TableName),
+			Type:  $2.(model.TableLockType),
+		}
+        }

 LockType:
 	"READ"
+        {
+		$$ = model.TableLockRead
+        }
 |	"READ" "LOCAL"
+        {
+		$$ = model.TableLockReadLocal
+        }
 |	"WRITE"
+        {
+		$$ = model.TableLockWrite
+        }
+|	"WRITE" "LOCAL"
+        {
+		$$ = model.TableLockWriteLocal
+        }

 TableLockList:
 	TableLock
+	{
+		$$ = []ast.TableLock{$1.(ast.TableLock)}
+	}
 |	TableLockList ',' TableLock
+	{
+		$$ = append($1.([]ast.TableLock), $3.(ast.TableLock))
+	}


 /********************************************************************

--- a/vendor/github.com/pingcap/parser/terror/terror.go
+++ b/vendor/github.com/pingcap/parser/terror/terror.go
@@ -148,6 +148,11 @@ func (ec ErrClass) New(code ErrCode, message string) *Error {
 	}
 }

+// NewStd calls New using the standard message for the error code
+func (ec ErrClass) NewStd(code ErrCode) *Error {
+	return ec.New(code, mysql.MySQLErrName[uint16(code)])
+}
+
 // Error implements error interface and adds integer Class and Code, so
 // errors with different message can be compared.
 type Error struct {

--- a/vendor/github.com/pingcap/parser/types/field_type.go
+++ b/vendor/github.com/pingcap/parser/types/field_type.go
@@ -201,8 +201,13 @@ func (ft *FieldType) String() string {
 func (ft *FieldType) Restore(ctx *format.RestoreCtx) error {
 	ctx.WriteKeyWord(TypeToStr(ft.Tp, ft.Charset))

+	precision := ft.Flen
+	scale := ft.Decimal
+
 	switch ft.Tp {
 	case mysql.TypeEnum, mysql.TypeSet:
+		precision = UnspecifiedLength
+		scale = UnspecifiedLength
 		ctx.WritePlain("(")
 		for i, e := range ft.Elems {
 			if i != 0 {
@@ -212,21 +217,17 @@ func (ft *FieldType) Restore(ctx *format.RestoreCtx) error {
 		}
 		ctx.WritePlain(")")
 	case mysql.TypeTimestamp, mysql.TypeDatetime, mysql.TypeDuration:
-		if ft.Flen > 0 && ft.Decimal > 0 {
-			ctx.WritePlainf("(%d)", ft.Decimal)
-		}
-	case mysql.TypeDouble, mysql.TypeFloat:
-		if ft.Flen > 0 && ft.Decimal > 0 {
-			ctx.WritePlainf("(%d,%d)", ft.Flen, ft.Decimal)
-		}
-	case mysql.TypeNewDecimal:
-		if ft.Flen > 0 && ft.Decimal > 0 {
-			ctx.WritePlainf("(%d,%d)", ft.Flen, ft.Decimal)
-		}
-	case mysql.TypeBit, mysql.TypeShort, mysql.TypeTiny, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeVarchar, mysql.TypeString, mysql.TypeVarString, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeBlob, mysql.TypeLongBlob, mysql.TypeYear:
-		if ft.Flen > 0 {
-			ctx.WritePlainf("(%d)", ft.Flen)
+		precision = ft.Decimal
+		scale = UnspecifiedLength
+	}
+
+	if precision != UnspecifiedLength {
+		ctx.WritePlainf("(%d", precision)
+		if scale != UnspecifiedLength {
+			ctx.WritePlainf(",%d", scale)
 		}
+		ctx.WritePlain(")")
+
 	}

 	if mysql.HasUnsignedFlag(ft.Flag) {

--- a/vendor/github.com/pingcap/tidb/sessionctx/stmtctx/stmtctx.go
+++ b/vendor/github.com/pingcap/tidb/sessionctx/stmtctx/stmtctx.go
@@ -24,6 +24,7 @@ import (
 	"github.com/pingcap/parser/mysql"
 	"github.com/pingcap/tidb/util/execdetails"
 	"github.com/pingcap/tidb/util/memory"
+	"go.uber.org/zap"
 )

 const (
@@ -54,6 +55,7 @@ type StatementContext struct {
 	InDeleteStmt           bool
 	InSelectStmt           bool
 	InLoadDataStmt         bool
+	InExplainStmt          bool
 	IgnoreTruncate         bool
 	IgnoreZeroInDate       bool
 	DupKeyAsWarning        bool
@@ -486,3 +488,21 @@ type CopTasksDetails struct {
 	MaxWaitAddress string
 	MaxWaitTime    time.Duration
 }
+
+// ToZapFields wraps the CopTasksDetails as zap.Fileds.
+func (d *CopTasksDetails) ToZapFields() (fields []zap.Field) {
+	if d.NumCopTasks == 0 {
+		return
+	}
+	fields = make([]zap.Field, 0, 10)
+	fields = append(fields, zap.Int("num_cop_tasks", d.NumCopTasks))
+	fields = append(fields, zap.String("process_avg_time", strconv.FormatFloat(d.AvgProcessTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("process_p90_time", strconv.FormatFloat(d.P90ProcessTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("process_max_time", strconv.FormatFloat(d.MaxProcessTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("process_max_addr", d.MaxProcessAddress))
+	fields = append(fields, zap.String("wait_avg_time", strconv.FormatFloat(d.AvgWaitTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("wait_p90_time", strconv.FormatFloat(d.P90WaitTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("wait_max_time", strconv.FormatFloat(d.MaxWaitTime.Seconds(), 'f', -1, 64)+"s"))
+	fields = append(fields, zap.String("wait_max_addr", d.MaxWaitAddress))
+	return fields
+}
--- a/vendor/github.com/pingcap/tidb/types/json/binary.go
+++ b/vendor/github.com/pingcap/tidb/types/json/binary.go
@@ -392,7 +392,12 @@ func ParseBinaryFromString(s string) (bj BinaryJSON, err error) {
 		err = ErrInvalidJSONText.GenWithStackByArgs("The document is empty")
 		return
 	}
-	if err = bj.UnmarshalJSON(hack.Slice(s)); err != nil {
+	data := hack.Slice(s)
+	if !json.Valid(data) {
+		err = ErrInvalidJSONText.GenWithStackByArgs("The document root must not be followed by other values.")
+		return
+	}
+	if err = bj.UnmarshalJSON(data); err != nil {
 		err = ErrInvalidJSONText.GenWithStackByArgs(err)
 	}
 	return

--- a/vendor/github.com/pingcap/tidb/util/execdetails/execdetails.go
+++ b/vendor/github.com/pingcap/tidb/util/execdetails/execdetails.go
@@ -23,6 +23,7 @@ import (
 	"time"

 	"github.com/pingcap/tipb/go-tipb"
+	"go.uber.org/zap"
 )

 // CommitDetailCtxKey presents CommitDetail info key in context.
@@ -128,6 +129,65 @@ func (d ExecDetails) String() string {
 	return strings.Join(parts, " ")
 }

+// ToZapFields wraps the ExecDetails as zap.Fields.
+func (d ExecDetails) ToZapFields() (fields []zap.Field) {
+	fields = make([]zap.Field, 0, 16)
+	if d.ProcessTime > 0 {
+		fields = append(fields, zap.String(strings.ToLower(ProcessTimeStr), strconv.FormatFloat(d.ProcessTime.Seconds(), 'f', -1, 64)+"s"))
+	}
+	if d.WaitTime > 0 {
+		fields = append(fields, zap.String(strings.ToLower(WaitTimeStr), strconv.FormatFloat(d.ProcessTime.Seconds(), 'f', -1, 64)+"s"))
+	}
+	if d.BackoffTime > 0 {
+		fields = append(fields, zap.String(strings.ToLower(BackoffTimeStr), strconv.FormatFloat(d.BackoffTime.Seconds(), 'f', -1, 64)+"s"))
+	}
+	if d.RequestCount > 0 {
+		fields = append(fields, zap.String(strings.ToLower(RequestCountStr), strconv.FormatInt(int64(d.RequestCount), 10)))
+	}
+	if d.TotalKeys > 0 {
+		fields = append(fields, zap.String(strings.ToLower(TotalKeysStr), strconv.FormatInt(d.TotalKeys, 10)))
+	}
+	if d.ProcessedKeys > 0 {
+		fields = append(fields, zap.String(strings.ToLower(ProcessKeysStr), strconv.FormatInt(d.ProcessedKeys, 10)))
+	}
+	commitDetails := d.CommitDetail
+	if commitDetails != nil {
+		if commitDetails.PrewriteTime > 0 {
+			fields = append(fields, zap.String("prewrite_time", fmt.Sprintf("%v", strconv.FormatFloat(commitDetails.PrewriteTime.Seconds(), 'f', -1, 64)+"s")))
+		}
+		if commitDetails.CommitTime > 0 {
+			fields = append(fields, zap.String("commit_time", fmt.Sprintf("%v", strconv.FormatFloat(commitDetails.CommitTime.Seconds(), 'f', -1, 64)+"s")))
+		}
+		if commitDetails.GetCommitTsTime > 0 {
+			fields = append(fields, zap.String("get_commit_ts_time", fmt.Sprintf("%v", strconv.FormatFloat(commitDetails.GetCommitTsTime.Seconds(), 'f', -1, 64)+"s")))
+		}
+		if commitDetails.TotalBackoffTime > 0 {
+			fields = append(fields, zap.String("total_backoff_time", fmt.Sprintf("%v", strconv.FormatFloat(commitDetails.TotalBackoffTime.Seconds(), 'f', -1, 64)+"s")))
+		}
+		resolveLockTime := atomic.LoadInt64(&commitDetails.ResolveLockTime)
+		if resolveLockTime > 0 {
+			fields = append(fields, zap.String("resolve_lock_time", fmt.Sprintf("%v", strconv.FormatFloat(time.Duration(resolveLockTime).Seconds(), 'f', -1, 64)+"s")))
+		}
+		if commitDetails.LocalLatchTime > 0 {
+			fields = append(fields, zap.String("local_latch_wait_time", fmt.Sprintf("%v", strconv.FormatFloat(commitDetails.LocalLatchTime.Seconds(), 'f', -1, 64)+"s")))
+		}
+		if commitDetails.WriteKeys > 0 {
+			fields = append(fields, zap.Int("write_keys", commitDetails.WriteKeys))
+		}
+		if commitDetails.WriteSize > 0 {
+			fields = append(fields, zap.Int("write_size", commitDetails.WriteSize))
+		}
+		prewriteRegionNum := atomic.LoadInt32(&commitDetails.PrewriteRegionNum)
+		if prewriteRegionNum > 0 {
+			fields = append(fields, zap.Int32("prewrite_region", prewriteRegionNum))
+		}
+		if commitDetails.TxnRetry > 0 {
+			fields = append(fields, zap.Int("txn_retry", commitDetails.TxnRetry))
+		}
+	}
+	return fields
+}
+
 // CopRuntimeStats collects cop tasks' execution info.
 type CopRuntimeStats struct {
 	sync.Mutex
@@ -257,8 +317,5 @@ func (e *RuntimeStats) SetRowNum(rowNum int64) {
 }

 func (e *RuntimeStats) String() string {
-	if e == nil {
-		return ""
-	}
 	return fmt.Sprintf("time:%v, loops:%d, rows:%d", time.Duration(e.consume), e.loop, e.rows)
 }
--- a/vendor/github.com/pingcap/tidb/util/logutil/log.go
+++ b/vendor/github.com/pingcap/tidb/util/logutil/log.go
@@ -131,30 +131,9 @@ func stringToLogLevel(level string) log.Level {
 	return defaultLogLevel
 }

-// logTypeToColor converts the Level to a color string.
-func logTypeToColor(level log.Level) string {
-	switch level {
-	case log.DebugLevel:
-		return "[0;37"
-	case log.InfoLevel:
-		return "[0;36"
-	case log.WarnLevel:
-		return "[0;33"
-	case log.ErrorLevel:
-		return "[0;31"
-	case log.FatalLevel:
-		return "[0;31"
-	case log.PanicLevel:
-		return "[0;31"
-	}
-
-	return "[0;37"
-}
-
 // textFormatter is for compatibility with ngaut/log
 type textFormatter struct {
 	DisableTimestamp bool
-	EnableColors     bool
 	EnableEntryOrder bool
 }

@@ -167,11 +146,6 @@ func (f *textFormatter) Format(entry *log.Entry) ([]byte, error) {
 		b = &bytes.Buffer{}
 	}

-	if f.EnableColors {
-		colorStr := logTypeToColor(entry.Level)
-		fmt.Fprintf(b, "\033%sm ", colorStr)
-	}
-
 	if !f.DisableTimestamp {
 		fmt.Fprintf(b, "%s ", entry.Time.Format(defaultLogTimeFormat))
 	}
@@ -201,9 +175,6 @@ func (f *textFormatter) Format(entry *log.Entry) ([]byte, error) {

 	b.WriteByte('\n')

-	if f.EnableColors {
-		b.WriteString("\033[0m")
-	}
 	return b.Bytes(), nil
 }

@@ -235,22 +206,6 @@ func stringToLogFormatter(format string, disableTimestamp bool) log.Formatter {
 		return &textFormatter{
 			DisableTimestamp: disableTimestamp,
 		}
-	case "json":
-		return &log.JSONFormatter{
-			TimestampFormat:  defaultLogTimeFormat,
-			DisableTimestamp: disableTimestamp,
-		}
-	case "console":
-		return &log.TextFormatter{
-			FullTimestamp:    true,
-			TimestampFormat:  defaultLogTimeFormat,
-			DisableTimestamp: disableTimestamp,
-		}
-	case "highlight":
-		return &textFormatter{
-			DisableTimestamp: disableTimestamp,
-			EnableColors:     true,
-		}
 	default:
 		return &textFormatter{}
 	}

--- a/vendor/github.com/pingcap/tidb/util/memory/action.go
+++ b/vendor/github.com/pingcap/tidb/util/memory/action.go
@@ -45,6 +45,7 @@ func (a *LogOnExceed) Action(t *Tracker) {
 		a.acted = true
 		logutil.Logger(context.Background()).Warn("memory exceeds quota",
 			zap.Error(errMemExceedThreshold.GenWithStackByArgs(t.label, t.BytesConsumed(), t.bytesLimit, t.String())))
+		return
 	}
 }


--- a/vendor/github.com/pingcap/tidb/util/memory/tracker.go
+++ b/vendor/github.com/pingcap/tidb/util/memory/tracker.go
@@ -182,9 +182,9 @@ func (t *Tracker) String() string {
 func (t *Tracker) toString(indent string, buffer *bytes.Buffer) {
 	fmt.Fprintf(buffer, "%s\"%s\"{\n", indent, t.label)
 	if t.bytesLimit > 0 {
-		fmt.Fprintf(buffer, "%s  \"quota\": %s\n", indent, t.bytesToString(t.bytesLimit))
+		fmt.Fprintf(buffer, "%s  \"quota\": %s\n", indent, t.BytesToString(t.bytesLimit))
 	}
-	fmt.Fprintf(buffer, "%s  \"consumed\": %s\n", indent, t.bytesToString(t.BytesConsumed()))
+	fmt.Fprintf(buffer, "%s  \"consumed\": %s\n", indent, t.BytesToString(t.BytesConsumed()))

 	t.mu.Lock()
 	for i := range t.mu.children {
@@ -196,7 +196,8 @@ func (t *Tracker) toString(indent string, buffer *bytes.Buffer) {
 	buffer.WriteString(indent + "}\n")
 }

-func (t *Tracker) bytesToString(numBytes int64) string {
+// BytesToString converts the memory consumption to a readable string.
+func (t *Tracker) BytesToString(numBytes int64) string {
 	GB := float64(numBytes) / float64(1<<30)
 	if GB > 1 {
 		return fmt.Sprintf("%v GB", GB)

--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -117,118 +117,118 @@
 			"revisionTime": "2019-03-07T07:54:52Z"
 		},
 		{
-			"checksumSHA1": "IB9wW2GmSlnLVDRkaUXcF3CJ15g=",
+			"checksumSHA1": "gkdPCV8bVezIdBd/w2RiZf7eXTU=",
 			"path": "github.com/pingcap/parser",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "qeft79GIpt7bP++Qlg1UNSdXL3E=",
+			"checksumSHA1": "/HUw+IEQjCkicSG7qSMWqRlmvz0=",
 			"path": "github.com/pingcap/parser/ast",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
 			"checksumSHA1": "xiv40YqnvHcbIhaEzJqjh5K7ehM=",
 			"path": "github.com/pingcap/parser/auth",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
 			"checksumSHA1": "EvDXpplklIXmKqLclzWzaN/uHKQ=",
 			"path": "github.com/pingcap/parser/charset",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
 			"checksumSHA1": "Aao6Mul/qqogOwPwM2arBKZkYZs=",
 			"path": "github.com/pingcap/parser/format",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "YN9BYMOMxEXjrUCPPYQREN90BC0=",
+			"checksumSHA1": "CvZtQeDgNfQUrGDi5mrv5osJ5F0=",
 			"path": "github.com/pingcap/parser/model",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "/qaOJqnSLO0dZbyQDnq75wUPiLo=",
+			"checksumSHA1": "02F5sAuKee53HMwsu6fx+iw5cnM=",
 			"path": "github.com/pingcap/parser/mysql",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
 			"checksumSHA1": "olapD16WCMBU9vrA5PtlERGFfXw=",
 			"path": "github.com/pingcap/parser/opcode",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "kNunWp0HfikkRiZlOzfD1bvHruM=",
+			"checksumSHA1": "L6rzy3sJU1RPf7AkJN+0zcwW/YY=",
 			"path": "github.com/pingcap/parser/terror",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "abJKAbu4Cro4oJZ2IeI+n+0R87A=",
+			"checksumSHA1": "EWbRvJs3Y1KLBaHnwaCHps3t0+4=",
 			"path": "github.com/pingcap/parser/types",
-			"revision": "89ae120307cc42a1cccc4daba2c589966db77055",
-			"revisionTime": "2019-05-23T11:32:41Z"
+			"revision": "3b36f86d9b7bba02fef99748e3a98069708a64f3",
+			"revisionTime": "2019-06-12T05:27:18Z"
 		},
 		{
-			"checksumSHA1": "t0O+34iPgOlRt020Cn36smUWhwQ=",
+			"checksumSHA1": "irgF5OsNQZiD589px9hV3scdp8U=",
 			"path": "github.com/pingcap/tidb/sessionctx/stmtctx",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
 			"checksumSHA1": "1INT6BSMg5WA9x4ftRegJBhDJQg=",
 			"path": "github.com/pingcap/tidb/types",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
-			"checksumSHA1": "PwXMuapqcWj1+hMEcRIJhLJ3NsY=",
+			"checksumSHA1": "HYVqavXulc59n0RyI/D1jZVKon4=",
 			"path": "github.com/pingcap/tidb/types/json",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
 			"checksumSHA1": "45zWX5Q6D6aTEWtc4p/lbD9WD4o=",
 			"path": "github.com/pingcap/tidb/types/parser_driver",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
-			"checksumSHA1": "za/7NvrgGTXpUf/A4/MCtgeNp+Y=",
+			"checksumSHA1": "dI3bZpUsujM1shEDvORNQj5FCN0=",
 			"path": "github.com/pingcap/tidb/util/execdetails",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
 			"checksumSHA1": "RdbHgQWMHjRtKjqPcTX81k1V3sw=",
 			"path": "github.com/pingcap/tidb/util/hack",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
-			"checksumSHA1": "JYbZwZe2uuqKVVV40ZU4G9zGEBE=",
+			"checksumSHA1": "16Cv4I5dFUSCuz0AufzUilN4IOI=",
 			"path": "github.com/pingcap/tidb/util/logutil",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
 			"checksumSHA1": "OveQu0ABBJmMEwmmthqSRQC2Ef0=",
 			"path": "github.com/pingcap/tidb/util/math",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
-			"checksumSHA1": "9q+/RZZoN4cq/FbCUCD0uVAyqeU=",
+			"checksumSHA1": "EoqVTAze03xNtGcKbsZT4eYx9bI=",
 			"path": "github.com/pingcap/tidb/util/memory",
-			"revision": "cc74145ffa9e48edcae0fb394618ada43b2776c0",
-			"revisionTime": "2019-05-24T06:40:04Z"
+			"revision": "7d27fa63d349b9d266682a3fff6e732c156cf1db",
+			"revisionTime": "2019-06-12T12:43:29Z"
 		},
 		{
 			"checksumSHA1": "QPIBwDNUFF5Whrnd41S3mkKa4gQ=",
@@ -485,62 +485,68 @@
 		{
 			"checksumSHA1": "aKn1oKcY74N8TRLm3Ayt7Q4bbI4=",
 			"path": "vitess.io/vitess/go/bytes2",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "bhE6CGQgZTIgLPp9lnvlKW/47xc=",
 			"path": "vitess.io/vitess/go/hack",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "RERqgxOX48XzRIoe5fQzvWSJV0Y=",
 			"path": "vitess.io/vitess/go/sqltypes",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "vAIRxI6MHsq3x1hLQwIyw5AvqtI=",
 			"path": "vitess.io/vitess/go/vt/log",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
+		},
+		{
+			"checksumSHA1": "/0K9CBbInkAhioqKX9ocBrJ6AKE=",
+			"path": "vitess.io/vitess/go/vt/proto/binlogdata",
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "87Zndvk3Y+M+QxMx3uFa0iSbvWY=",
 			"path": "vitess.io/vitess/go/vt/proto/query",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "xpcb9NfXMEeHhEPStbJntIfa5GQ=",
 			"path": "vitess.io/vitess/go/vt/proto/topodata",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
-			"checksumSHA1": "l9fmSuOJyoq+EKM4QxfoSw8hLPY=",
+			"checksumSHA1": "Ie634JZ/Np9603mG+PQ0ZkUsaQI=",
 			"path": "vitess.io/vitess/go/vt/proto/vtgate",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "qz32abYdmm9NfKTc++K0l1EvXXM=",
 			"path": "vitess.io/vitess/go/vt/proto/vtrpc",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
 			"checksumSHA1": "/V79kL29yMBxAofQBL/XqxJv/GE=",
 			"path": "vitess.io/vitess/go/vt/sqlparser",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		},
 		{
-			"checksumSHA1": "qhGH2j3onpaSh+fbs1fKPoTxUcw=",
+			"checksumSHA1": "z9+F/lA1Xrl5S16LKssUH8VL6hs=",
 			"path": "vitess.io/vitess/go/vt/vterrors",
-			"revision": "eb2d057927b37c5a6f144ab5baa762881cffae8d",
-			"revisionTime": "2019-05-23T12:28:24Z"
+			"revision": "22dbada8b16e2c969dd60c77f4e6a346c70d5952",
+			"revisionTime": "2019-06-11T03:26:25Z"
 		}
 	],
 	"rootPath": "github.com/XiaoMi/soar"

--- a/vendor/vitess.io/vitess/go/vt/proto/binlogdata/binlogdata.pb.go
+++ b/vendor/vitess.io/vitess/go/vt/proto/binlogdata/binlogdata.pb.go
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: binlogdata.proto
+
+package binlogdata // import "vitess.io/vitess/go/vt/proto/binlogdata"
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import query "vitess.io/vitess/go/vt/proto/query"
+import topodata "vitess.io/vitess/go/vt/proto/topodata"
+import vtrpc "vitess.io/vitess/go/vt/proto/vtrpc"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// OnDDLAction lists the possible actions for DDLs.
+type OnDDLAction int32
+
+const (
+	OnDDLAction_IGNORE      OnDDLAction = 0
+	OnDDLAction_STOP        OnDDLAction = 1
+	OnDDLAction_EXEC        OnDDLAction = 2
+	OnDDLAction_EXEC_IGNORE OnDDLAction = 3
+)
+
+var OnDDLAction_name = map[int32]string{
+	0: "IGNORE",
+	1: "STOP",
+	2: "EXEC",
+	3: "EXEC_IGNORE",
+}
+var OnDDLAction_value = map[string]int32{
+	"IGNORE":      0,
+	"STOP":        1,
+	"EXEC":        2,
+	"EXEC_IGNORE": 3,
+}
+
+func (x OnDDLAction) String() string {
+	return proto.EnumName(OnDDLAction_name, int32(x))
+}
+func (OnDDLAction) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{0}
+}
+
+// VEventType enumerates the event types.
+// This list is comprehensive. Many of these types
+// will not be encountered in RBR mode.
+type VEventType int32
+
+const (
+	VEventType_UNKNOWN   VEventType = 0
+	VEventType_GTID      VEventType = 1
+	VEventType_BEGIN     VEventType = 2
+	VEventType_COMMIT    VEventType = 3
+	VEventType_ROLLBACK  VEventType = 4
+	VEventType_DDL       VEventType = 5
+	VEventType_INSERT    VEventType = 6
+	VEventType_REPLACE   VEventType = 7
+	VEventType_UPDATE    VEventType = 8
+	VEventType_DELETE    VEventType = 9
+	VEventType_SET       VEventType = 10
+	VEventType_OTHER     VEventType = 11
+	VEventType_ROW       VEventType = 12
+	VEventType_FIELD     VEventType = 13
+	VEventType_HEARTBEAT VEventType = 14
+	VEventType_VGTID     VEventType = 15
+)
+
+var VEventType_name = map[int32]string{
+	0:  "UNKNOWN",
+	1:  "GTID",
+	2:  "BEGIN",
+	3:  "COMMIT",
+	4:  "ROLLBACK",
+	5:  "DDL",
+	6:  "INSERT",
+	7:  "REPLACE",
+	8:  "UPDATE",
+	9:  "DELETE",
+	10: "SET",
+	11: "OTHER",
+	12: "ROW",
+	13: "FIELD",
+	14: "HEARTBEAT",
+	15: "VGTID",
+}
+var VEventType_value = map[string]int32{
+	"UNKNOWN":   0,
+	"GTID":      1,
+	"BEGIN":     2,
+	"COMMIT":    3,
+	"ROLLBACK":  4,
+	"DDL":       5,
+	"INSERT":    6,
+	"REPLACE":   7,
+	"UPDATE":    8,
+	"DELETE":    9,
+	"SET":       10,
+	"OTHER":     11,
+	"ROW":       12,
+	"FIELD":     13,
+	"HEARTBEAT": 14,
+	"VGTID":     15,
+}
+
+func (x VEventType) String() string {
+	return proto.EnumName(VEventType_name, int32(x))
+}
+func (VEventType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{1}
+}
+
+type BinlogTransaction_Statement_Category int32
+
+const (
+	BinlogTransaction_Statement_BL_UNRECOGNIZED BinlogTransaction_Statement_Category = 0
+	BinlogTransaction_Statement_BL_BEGIN        BinlogTransaction_Statement_Category = 1
+	BinlogTransaction_Statement_BL_COMMIT       BinlogTransaction_Statement_Category = 2
+	BinlogTransaction_Statement_BL_ROLLBACK     BinlogTransaction_Statement_Category = 3
+	// BL_DML is deprecated.
+	BinlogTransaction_Statement_BL_DML_DEPRECATED BinlogTransaction_Statement_Category = 4
+	BinlogTransaction_Statement_BL_DDL            BinlogTransaction_Statement_Category = 5
+	BinlogTransaction_Statement_BL_SET            BinlogTransaction_Statement_Category = 6
+	BinlogTransaction_Statement_BL_INSERT         BinlogTransaction_Statement_Category = 7
+	BinlogTransaction_Statement_BL_UPDATE         BinlogTransaction_Statement_Category = 8
+	BinlogTransaction_Statement_BL_DELETE         BinlogTransaction_Statement_Category = 9
+)
+
+var BinlogTransaction_Statement_Category_name = map[int32]string{
+	0: "BL_UNRECOGNIZED",
+	1: "BL_BEGIN",
+	2: "BL_COMMIT",
+	3: "BL_ROLLBACK",
+	4: "BL_DML_DEPRECATED",
+	5: "BL_DDL",
+	6: "BL_SET",
+	7: "BL_INSERT",
+	8: "BL_UPDATE",
+	9: "BL_DELETE",
+}
+var BinlogTransaction_Statement_Category_value = map[string]int32{
+	"BL_UNRECOGNIZED":   0,
+	"BL_BEGIN":          1,
+	"BL_COMMIT":         2,
+	"BL_ROLLBACK":       3,
+	"BL_DML_DEPRECATED": 4,
+	"BL_DDL":            5,
+	"BL_SET":            6,
+	"BL_INSERT":         7,
+	"BL_UPDATE":         8,
+	"BL_DELETE":         9,
+}
+
+func (x BinlogTransaction_Statement_Category) String() string {
+	return proto.EnumName(BinlogTransaction_Statement_Category_name, int32(x))
+}
+func (BinlogTransaction_Statement_Category) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{1, 0, 0}
+}
+
+// Charset is the per-statement charset info from a QUERY_EVENT binlog entry.
+type Charset struct {
+	// @@session.character_set_client
+	Client int32 `protobuf:"varint,1,opt,name=client,proto3" json:"client,omitempty"`
+	// @@session.collation_connection
+	Conn int32 `protobuf:"varint,2,opt,name=conn,proto3" json:"conn,omitempty"`
+	// @@session.collation_server
+	Server               int32    `protobuf:"varint,3,opt,name=server,proto3" json:"server,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Charset) Reset()         { *m = Charset{} }
+func (m *Charset) String() string { return proto.CompactTextString(m) }
+func (*Charset) ProtoMessage()    {}
+func (*Charset) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{0}
+}
+func (m *Charset) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Charset.Unmarshal(m, b)
+}
+func (m *Charset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Charset.Marshal(b, m, deterministic)
+}
+func (dst *Charset) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Charset.Merge(dst, src)
+}
+func (m *Charset) XXX_Size() int {
+	return xxx_messageInfo_Charset.Size(m)
+}
+func (m *Charset) XXX_DiscardUnknown() {
+	xxx_messageInfo_Charset.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Charset proto.InternalMessageInfo
+
+func (m *Charset) GetClient() int32 {
+	if m != nil {
+		return m.Client
+	}
+	return 0
+}
+
+func (m *Charset) GetConn() int32 {
+	if m != nil {
+		return m.Conn
+	}
+	return 0
+}
+
+func (m *Charset) GetServer() int32 {
+	if m != nil {
+		return m.Server
+	}
+	return 0
+}
+
+// BinlogTransaction describes a transaction inside the binlogs.
+// It is streamed by vttablet for filtered replication, used during resharding.
+type BinlogTransaction struct {
+	// the statements in this transaction
+	Statements []*BinlogTransaction_Statement `protobuf:"bytes,1,rep,name=statements,proto3" json:"statements,omitempty"`
+	// The Event Token for this event.
+	EventToken           *query.EventToken `protobuf:"bytes,4,opt,name=event_token,json=eventToken,proto3" json:"event_token,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
+	XXX_unrecognized     []byte            `json:"-"`
+	XXX_sizecache        int32             `json:"-"`
+}
+
+func (m *BinlogTransaction) Reset()         { *m = BinlogTransaction{} }
+func (m *BinlogTransaction) String() string { return proto.CompactTextString(m) }
+func (*BinlogTransaction) ProtoMessage()    {}
+func (*BinlogTransaction) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{1}
+}
+func (m *BinlogTransaction) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BinlogTransaction.Unmarshal(m, b)
+}
+func (m *BinlogTransaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BinlogTransaction.Marshal(b, m, deterministic)
+}
+func (dst *BinlogTransaction) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BinlogTransaction.Merge(dst, src)
+}
+func (m *BinlogTransaction) XXX_Size() int {
+	return xxx_messageInfo_BinlogTransaction.Size(m)
+}
+func (m *BinlogTransaction) XXX_DiscardUnknown() {
+	xxx_messageInfo_BinlogTransaction.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BinlogTransaction proto.InternalMessageInfo
+
+func (m *BinlogTransaction) GetStatements() []*BinlogTransaction_Statement {
+	if m != nil {
+		return m.Statements
+	}
+	return nil
+}
+
+func (m *BinlogTransaction) GetEventToken() *query.EventToken {
+	if m != nil {
+		return m.EventToken
+	}
+	return nil
+}
+
+type BinlogTransaction_Statement struct {
+	// what type of statement is this?
+	Category BinlogTransaction_Statement_Category `protobuf:"varint,1,opt,name=category,proto3,enum=binlogdata.BinlogTransaction_Statement_Category" json:"category,omitempty"`
+	// charset of this statement, if different from pre-negotiated default.
+	Charset *Charset `protobuf:"bytes,2,opt,name=charset,proto3" json:"charset,omitempty"`
+	// the sql
+	Sql                  []byte   `protobuf:"bytes,3,opt,name=sql,proto3" json:"sql,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *BinlogTransaction_Statement) Reset()         { *m = BinlogTransaction_Statement{} }
+func (m *BinlogTransaction_Statement) String() string { return proto.CompactTextString(m) }
+func (*BinlogTransaction_Statement) ProtoMessage()    {}
+func (*BinlogTransaction_Statement) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{1, 0}
+}
+func (m *BinlogTransaction_Statement) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BinlogTransaction_Statement.Unmarshal(m, b)
+}
+func (m *BinlogTransaction_Statement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BinlogTransaction_Statement.Marshal(b, m, deterministic)
+}
+func (dst *BinlogTransaction_Statement) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BinlogTransaction_Statement.Merge(dst, src)
+}
+func (m *BinlogTransaction_Statement) XXX_Size() int {
+	return xxx_messageInfo_BinlogTransaction_Statement.Size(m)
+}
+func (m *BinlogTransaction_Statement) XXX_DiscardUnknown() {
+	xxx_messageInfo_BinlogTransaction_Statement.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BinlogTransaction_Statement proto.InternalMessageInfo
+
+func (m *BinlogTransaction_Statement) GetCategory() BinlogTransaction_Statement_Category {
+	if m != nil {
+		return m.Category
+	}
+	return BinlogTransaction_Statement_BL_UNRECOGNIZED
+}
+
+func (m *BinlogTransaction_Statement) GetCharset() *Charset {
+	if m != nil {
+		return m.Charset
+	}
+	return nil
+}
+
+func (m *BinlogTransaction_Statement) GetSql() []byte {
+	if m != nil {
+		return m.Sql
+	}
+	return nil
+}
+
+// StreamKeyRangeRequest is the payload to StreamKeyRange
+type StreamKeyRangeRequest struct {
+	// where to start
+	Position string `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"`
+	// what to get
+	KeyRange *topodata.KeyRange `protobuf:"bytes,2,opt,name=key_range,json=keyRange,proto3" json:"key_range,omitempty"`
+	// default charset on the player side
+	Charset              *Charset `protobuf:"bytes,3,opt,name=charset,proto3" json:"charset,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StreamKeyRangeRequest) Reset()         { *m = StreamKeyRangeRequest{} }
+func (m *StreamKeyRangeRequest) String() string { return proto.CompactTextString(m) }
+func (*StreamKeyRangeRequest) ProtoMessage()    {}
+func (*StreamKeyRangeRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{2}
+}
+func (m *StreamKeyRangeRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StreamKeyRangeRequest.Unmarshal(m, b)
+}
+func (m *StreamKeyRangeRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StreamKeyRangeRequest.Marshal(b, m, deterministic)
+}
+func (dst *StreamKeyRangeRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StreamKeyRangeRequest.Merge(dst, src)
+}
+func (m *StreamKeyRangeRequest) XXX_Size() int {
+	return xxx_messageInfo_StreamKeyRangeRequest.Size(m)
+}
+func (m *StreamKeyRangeRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_StreamKeyRangeRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StreamKeyRangeRequest proto.InternalMessageInfo
+
+func (m *StreamKeyRangeRequest) GetPosition() string {
+	if m != nil {
+		return m.Position
+	}
+	return ""
+}
+
+func (m *StreamKeyRangeRequest) GetKeyRange() *topodata.KeyRange {
+	if m != nil {
+		return m.KeyRange
+	}
+	return nil
+}
+
+func (m *StreamKeyRangeRequest) GetCharset() *Charset {
+	if m != nil {
+		return m.Charset
+	}
+	return nil
+}
+
+// StreamKeyRangeResponse is the response from StreamKeyRange
+type StreamKeyRangeResponse struct {
+	BinlogTransaction    *BinlogTransaction `protobuf:"bytes,1,opt,name=binlog_transaction,json=binlogTransaction,proto3" json:"binlog_transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *StreamKeyRangeResponse) Reset()         { *m = StreamKeyRangeResponse{} }
+func (m *StreamKeyRangeResponse) String() string { return proto.CompactTextString(m) }
+func (*StreamKeyRangeResponse) ProtoMessage()    {}
+func (*StreamKeyRangeResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{3}
+}
+func (m *StreamKeyRangeResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StreamKeyRangeResponse.Unmarshal(m, b)
+}
+func (m *StreamKeyRangeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StreamKeyRangeResponse.Marshal(b, m, deterministic)
+}
+func (dst *StreamKeyRangeResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StreamKeyRangeResponse.Merge(dst, src)
+}
+func (m *StreamKeyRangeResponse) XXX_Size() int {
+	return xxx_messageInfo_StreamKeyRangeResponse.Size(m)
+}
+func (m *StreamKeyRangeResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_StreamKeyRangeResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StreamKeyRangeResponse proto.InternalMessageInfo
+
+func (m *StreamKeyRangeResponse) GetBinlogTransaction() *BinlogTransaction {
+	if m != nil {
+		return m.BinlogTransaction
+	}
+	return nil
+}
+
+// StreamTablesRequest is the payload to StreamTables
+type StreamTablesRequest struct {
+	// where to start
+	Position string `protobuf:"bytes,1,opt,name=position,proto3" json:"position,omitempty"`
+	// what to get
+	Tables []string `protobuf:"bytes,2,rep,name=tables,proto3" json:"tables,omitempty"`
+	// default charset on the player side
+	Charset              *Charset `protobuf:"bytes,3,opt,name=charset,proto3" json:"charset,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *StreamTablesRequest) Reset()         { *m = StreamTablesRequest{} }
+func (m *StreamTablesRequest) String() string { return proto.CompactTextString(m) }
+func (*StreamTablesRequest) ProtoMessage()    {}
+func (*StreamTablesRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{4}
+}
+func (m *StreamTablesRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StreamTablesRequest.Unmarshal(m, b)
+}
+func (m *StreamTablesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StreamTablesRequest.Marshal(b, m, deterministic)
+}
+func (dst *StreamTablesRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StreamTablesRequest.Merge(dst, src)
+}
+func (m *StreamTablesRequest) XXX_Size() int {
+	return xxx_messageInfo_StreamTablesRequest.Size(m)
+}
+func (m *StreamTablesRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_StreamTablesRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StreamTablesRequest proto.InternalMessageInfo
+
+func (m *StreamTablesRequest) GetPosition() string {
+	if m != nil {
+		return m.Position
+	}
+	return ""
+}
+
+func (m *StreamTablesRequest) GetTables() []string {
+	if m != nil {
+		return m.Tables
+	}
+	return nil
+}
+
+func (m *StreamTablesRequest) GetCharset() *Charset {
+	if m != nil {
+		return m.Charset
+	}
+	return nil
+}
+
+// StreamTablesResponse is the response from StreamTables
+type StreamTablesResponse struct {
+	BinlogTransaction    *BinlogTransaction `protobuf:"bytes,1,opt,name=binlog_transaction,json=binlogTransaction,proto3" json:"binlog_transaction,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *StreamTablesResponse) Reset()         { *m = StreamTablesResponse{} }
+func (m *StreamTablesResponse) String() string { return proto.CompactTextString(m) }
+func (*StreamTablesResponse) ProtoMessage()    {}
+func (*StreamTablesResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{5}
+}
+func (m *StreamTablesResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_StreamTablesResponse.Unmarshal(m, b)
+}
+func (m *StreamTablesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_StreamTablesResponse.Marshal(b, m, deterministic)
+}
+func (dst *StreamTablesResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_StreamTablesResponse.Merge(dst, src)
+}
+func (m *StreamTablesResponse) XXX_Size() int {
+	return xxx_messageInfo_StreamTablesResponse.Size(m)
+}
+func (m *StreamTablesResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_StreamTablesResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_StreamTablesResponse proto.InternalMessageInfo
+
+func (m *StreamTablesResponse) GetBinlogTransaction() *BinlogTransaction {
+	if m != nil {
+		return m.BinlogTransaction
+	}
+	return nil
+}
+
+// Rule represents one rule.
+type Rule struct {
+	// match can be a table name or a regular expression
+	// delineated by '/' and '/'.
+	Match string `protobuf:"bytes,1,opt,name=match,proto3" json:"match,omitempty"`
+	// filter can be an empty string or keyrange if the match
+	// is a regular expression. Otherwise, it must be a select
+	// query.
+	Filter               string   `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Rule) Reset()         { *m = Rule{} }
+func (m *Rule) String() string { return proto.CompactTextString(m) }
+func (*Rule) ProtoMessage()    {}
+func (*Rule) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{6}
+}
+func (m *Rule) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Rule.Unmarshal(m, b)
+}
+func (m *Rule) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Rule.Marshal(b, m, deterministic)
+}
+func (dst *Rule) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Rule.Merge(dst, src)
+}
+func (m *Rule) XXX_Size() int {
+	return xxx_messageInfo_Rule.Size(m)
+}
+func (m *Rule) XXX_DiscardUnknown() {
+	xxx_messageInfo_Rule.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Rule proto.InternalMessageInfo
+
+func (m *Rule) GetMatch() string {
+	if m != nil {
+		return m.Match
+	}
+	return ""
+}
+
+func (m *Rule) GetFilter() string {
+	if m != nil {
+		return m.Filter
+	}
+	return ""
+}
+
+// Filter represents a list of ordered rules. First match
+// wins.
+type Filter struct {
+	Rules                []*Rule  `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *Filter) Reset()         { *m = Filter{} }
+func (m *Filter) String() string { return proto.CompactTextString(m) }
+func (*Filter) ProtoMessage()    {}
+func (*Filter) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{7}
+}
+func (m *Filter) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_Filter.Unmarshal(m, b)
+}
+func (m *Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_Filter.Marshal(b, m, deterministic)
+}
+func (dst *Filter) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_Filter.Merge(dst, src)
+}
+func (m *Filter) XXX_Size() int {
+	return xxx_messageInfo_Filter.Size(m)
+}
+func (m *Filter) XXX_DiscardUnknown() {
+	xxx_messageInfo_Filter.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Filter proto.InternalMessageInfo
+
+func (m *Filter) GetRules() []*Rule {
+	if m != nil {
+		return m.Rules
+	}
+	return nil
+}
+
+// BinlogSource specifies the source  and filter parameters for
+// Filtered Replication. It currently supports a keyrange
+// or a list of tables.
+type BinlogSource struct {
+	// the source keyspace
+	Keyspace string `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
+	// the source shard
+	Shard string `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
+	// the source tablet type
+	TabletType topodata.TabletType `protobuf:"varint,3,opt,name=tablet_type,json=tabletType,proto3,enum=topodata.TabletType" json:"tablet_type,omitempty"`
+	// key_range is set if the request is for a keyrange
+	KeyRange *topodata.KeyRange `protobuf:"bytes,4,opt,name=key_range,json=keyRange,proto3" json:"key_range,omitempty"`
+	// tables is set if the request is for a list of tables
+	Tables []string `protobuf:"bytes,5,rep,name=tables,proto3" json:"tables,omitempty"`
+	// filter is set if we're using the generalized representation
+	// for the filter.
+	Filter *Filter `protobuf:"bytes,6,opt,name=filter,proto3" json:"filter,omitempty"`
+	// on_ddl specifies the action to be taken when a DDL is encountered.
+	OnDdl                OnDDLAction `protobuf:"varint,7,opt,name=on_ddl,json=onDdl,proto3,enum=binlogdata.OnDDLAction" json:"on_ddl,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
+	XXX_unrecognized     []byte      `json:"-"`
+	XXX_sizecache        int32       `json:"-"`
+}
+
+func (m *BinlogSource) Reset()         { *m = BinlogSource{} }
+func (m *BinlogSource) String() string { return proto.CompactTextString(m) }
+func (*BinlogSource) ProtoMessage()    {}
+func (*BinlogSource) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{8}
+}
+func (m *BinlogSource) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_BinlogSource.Unmarshal(m, b)
+}
+func (m *BinlogSource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_BinlogSource.Marshal(b, m, deterministic)
+}
+func (dst *BinlogSource) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_BinlogSource.Merge(dst, src)
+}
+func (m *BinlogSource) XXX_Size() int {
+	return xxx_messageInfo_BinlogSource.Size(m)
+}
+func (m *BinlogSource) XXX_DiscardUnknown() {
+	xxx_messageInfo_BinlogSource.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_BinlogSource proto.InternalMessageInfo
+
+func (m *BinlogSource) GetKeyspace() string {
+	if m != nil {
+		return m.Keyspace
+	}
+	return ""
+}
+
+func (m *BinlogSource) GetShard() string {
+	if m != nil {
+		return m.Shard
+	}
+	return ""
+}
+
+func (m *BinlogSource) GetTabletType() topodata.TabletType {
+	if m != nil {
+		return m.TabletType
+	}
+	return topodata.TabletType_UNKNOWN
+}
+
+func (m *BinlogSource) GetKeyRange() *topodata.KeyRange {
+	if m != nil {
+		return m.KeyRange
+	}
+	return nil
+}
+
+func (m *BinlogSource) GetTables() []string {
+	if m != nil {
+		return m.Tables
+	}
+	return nil
+}
+
+func (m *BinlogSource) GetFilter() *Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+func (m *BinlogSource) GetOnDdl() OnDDLAction {
+	if m != nil {
+		return m.OnDdl
+	}
+	return OnDDLAction_IGNORE
+}
+
+// RowChange represents one row change
+type RowChange struct {
+	Before               *query.Row `protobuf:"bytes,1,opt,name=before,proto3" json:"before,omitempty"`
+	After                *query.Row `protobuf:"bytes,2,opt,name=after,proto3" json:"after,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
+	XXX_unrecognized     []byte     `json:"-"`
+	XXX_sizecache        int32      `json:"-"`
+}
+
+func (m *RowChange) Reset()         { *m = RowChange{} }
+func (m *RowChange) String() string { return proto.CompactTextString(m) }
+func (*RowChange) ProtoMessage()    {}
+func (*RowChange) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{9}
+}
+func (m *RowChange) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RowChange.Unmarshal(m, b)
+}
+func (m *RowChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RowChange.Marshal(b, m, deterministic)
+}
+func (dst *RowChange) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RowChange.Merge(dst, src)
+}
+func (m *RowChange) XXX_Size() int {
+	return xxx_messageInfo_RowChange.Size(m)
+}
+func (m *RowChange) XXX_DiscardUnknown() {
+	xxx_messageInfo_RowChange.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RowChange proto.InternalMessageInfo
+
+func (m *RowChange) GetBefore() *query.Row {
+	if m != nil {
+		return m.Before
+	}
+	return nil
+}
+
+func (m *RowChange) GetAfter() *query.Row {
+	if m != nil {
+		return m.After
+	}
+	return nil
+}
+
+// RowEvent represent row events for one table
+type RowEvent struct {
+	TableName            string       `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
+	RowChanges           []*RowChange `protobuf:"bytes,2,rep,name=row_changes,json=rowChanges,proto3" json:"row_changes,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *RowEvent) Reset()         { *m = RowEvent{} }
+func (m *RowEvent) String() string { return proto.CompactTextString(m) }
+func (*RowEvent) ProtoMessage()    {}
+func (*RowEvent) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{10}
+}
+func (m *RowEvent) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_RowEvent.Unmarshal(m, b)
+}
+func (m *RowEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_RowEvent.Marshal(b, m, deterministic)
+}
+func (dst *RowEvent) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_RowEvent.Merge(dst, src)
+}
+func (m *RowEvent) XXX_Size() int {
+	return xxx_messageInfo_RowEvent.Size(m)
+}
+func (m *RowEvent) XXX_DiscardUnknown() {
+	xxx_messageInfo_RowEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_RowEvent proto.InternalMessageInfo
+
+func (m *RowEvent) GetTableName() string {
+	if m != nil {
+		return m.TableName
+	}
+	return ""
+}
+
+func (m *RowEvent) GetRowChanges() []*RowChange {
+	if m != nil {
+		return m.RowChanges
+	}
+	return nil
+}
+
+type FieldEvent struct {
+	TableName            string         `protobuf:"bytes,1,opt,name=table_name,json=tableName,proto3" json:"table_name,omitempty"`
+	Fields               []*query.Field `protobuf:"bytes,2,rep,name=fields,proto3" json:"fields,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *FieldEvent) Reset()         { *m = FieldEvent{} }
+func (m *FieldEvent) String() string { return proto.CompactTextString(m) }
+func (*FieldEvent) ProtoMessage()    {}
+func (*FieldEvent) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{11}
+}
+func (m *FieldEvent) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_FieldEvent.Unmarshal(m, b)
+}
+func (m *FieldEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_FieldEvent.Marshal(b, m, deterministic)
+}
+func (dst *FieldEvent) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_FieldEvent.Merge(dst, src)
+}
+func (m *FieldEvent) XXX_Size() int {
+	return xxx_messageInfo_FieldEvent.Size(m)
+}
+func (m *FieldEvent) XXX_DiscardUnknown() {
+	xxx_messageInfo_FieldEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_FieldEvent proto.InternalMessageInfo
+
+func (m *FieldEvent) GetTableName() string {
+	if m != nil {
+		return m.TableName
+	}
+	return ""
+}
+
+func (m *FieldEvent) GetFields() []*query.Field {
+	if m != nil {
+		return m.Fields
+	}
+	return nil
+}
+
+type ShardGtid struct {
+	Keyspace             string   `protobuf:"bytes,1,opt,name=keyspace,proto3" json:"keyspace,omitempty"`
+	Shard                string   `protobuf:"bytes,2,opt,name=shard,proto3" json:"shard,omitempty"`
+	Gtid                 string   `protobuf:"bytes,3,opt,name=gtid,proto3" json:"gtid,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *ShardGtid) Reset()         { *m = ShardGtid{} }
+func (m *ShardGtid) String() string { return proto.CompactTextString(m) }
+func (*ShardGtid) ProtoMessage()    {}
+func (*ShardGtid) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{12}
+}
+func (m *ShardGtid) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_ShardGtid.Unmarshal(m, b)
+}
+func (m *ShardGtid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_ShardGtid.Marshal(b, m, deterministic)
+}
+func (dst *ShardGtid) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ShardGtid.Merge(dst, src)
+}
+func (m *ShardGtid) XXX_Size() int {
+	return xxx_messageInfo_ShardGtid.Size(m)
+}
+func (m *ShardGtid) XXX_DiscardUnknown() {
+	xxx_messageInfo_ShardGtid.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ShardGtid proto.InternalMessageInfo
+
+func (m *ShardGtid) GetKeyspace() string {
+	if m != nil {
+		return m.Keyspace
+	}
+	return ""
+}
+
+func (m *ShardGtid) GetShard() string {
+	if m != nil {
+		return m.Shard
+	}
+	return ""
+}
+
+func (m *ShardGtid) GetGtid() string {
+	if m != nil {
+		return m.Gtid
+	}
+	return ""
+}
+
+type VGtid struct {
+	ShardGtids           []*ShardGtid `protobuf:"bytes,1,rep,name=shard_gtids,json=shardGtids,proto3" json:"shard_gtids,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
+	XXX_unrecognized     []byte       `json:"-"`
+	XXX_sizecache        int32        `json:"-"`
+}
+
+func (m *VGtid) Reset()         { *m = VGtid{} }
+func (m *VGtid) String() string { return proto.CompactTextString(m) }
+func (*VGtid) ProtoMessage()    {}
+func (*VGtid) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{13}
+}
+func (m *VGtid) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VGtid.Unmarshal(m, b)
+}
+func (m *VGtid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VGtid.Marshal(b, m, deterministic)
+}
+func (dst *VGtid) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VGtid.Merge(dst, src)
+}
+func (m *VGtid) XXX_Size() int {
+	return xxx_messageInfo_VGtid.Size(m)
+}
+func (m *VGtid) XXX_DiscardUnknown() {
+	xxx_messageInfo_VGtid.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VGtid proto.InternalMessageInfo
+
+func (m *VGtid) GetShardGtids() []*ShardGtid {
+	if m != nil {
+		return m.ShardGtids
+	}
+	return nil
+}
+
+// VEvent represents a vstream event
+type VEvent struct {
+	Type       VEventType  `protobuf:"varint,1,opt,name=type,proto3,enum=binlogdata.VEventType" json:"type,omitempty"`
+	Timestamp  int64       `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
+	Gtid       string      `protobuf:"bytes,3,opt,name=gtid,proto3" json:"gtid,omitempty"`
+	Ddl        string      `protobuf:"bytes,4,opt,name=ddl,proto3" json:"ddl,omitempty"`
+	RowEvent   *RowEvent   `protobuf:"bytes,5,opt,name=row_event,json=rowEvent,proto3" json:"row_event,omitempty"`
+	FieldEvent *FieldEvent `protobuf:"bytes,6,opt,name=field_event,json=fieldEvent,proto3" json:"field_event,omitempty"`
+	Vgtid      *VGtid      `protobuf:"bytes,7,opt,name=vgtid,proto3" json:"vgtid,omitempty"`
+	// current_time specifies the current time to handle clock skew.
+	CurrentTime          int64    `protobuf:"varint,20,opt,name=current_time,json=currentTime,proto3" json:"current_time,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *VEvent) Reset()         { *m = VEvent{} }
+func (m *VEvent) String() string { return proto.CompactTextString(m) }
+func (*VEvent) ProtoMessage()    {}
+func (*VEvent) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{14}
+}
+func (m *VEvent) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VEvent.Unmarshal(m, b)
+}
+func (m *VEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VEvent.Marshal(b, m, deterministic)
+}
+func (dst *VEvent) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VEvent.Merge(dst, src)
+}
+func (m *VEvent) XXX_Size() int {
+	return xxx_messageInfo_VEvent.Size(m)
+}
+func (m *VEvent) XXX_DiscardUnknown() {
+	xxx_messageInfo_VEvent.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VEvent proto.InternalMessageInfo
+
+func (m *VEvent) GetType() VEventType {
+	if m != nil {
+		return m.Type
+	}
+	return VEventType_UNKNOWN
+}
+
+func (m *VEvent) GetTimestamp() int64 {
+	if m != nil {
+		return m.Timestamp
+	}
+	return 0
+}
+
+func (m *VEvent) GetGtid() string {
+	if m != nil {
+		return m.Gtid
+	}
+	return ""
+}
+
+func (m *VEvent) GetDdl() string {
+	if m != nil {
+		return m.Ddl
+	}
+	return ""
+}
+
+func (m *VEvent) GetRowEvent() *RowEvent {
+	if m != nil {
+		return m.RowEvent
+	}
+	return nil
+}
+
+func (m *VEvent) GetFieldEvent() *FieldEvent {
+	if m != nil {
+		return m.FieldEvent
+	}
+	return nil
+}
+
+func (m *VEvent) GetVgtid() *VGtid {
+	if m != nil {
+		return m.Vgtid
+	}
+	return nil
+}
+
+func (m *VEvent) GetCurrentTime() int64 {
+	if m != nil {
+		return m.CurrentTime
+	}
+	return 0
+}
+
+// VStreamRequest is the payload for VStream
+type VStreamRequest struct {
+	EffectiveCallerId    *vtrpc.CallerID       `protobuf:"bytes,1,opt,name=effective_caller_id,json=effectiveCallerId,proto3" json:"effective_caller_id,omitempty"`
+	ImmediateCallerId    *query.VTGateCallerID `protobuf:"bytes,2,opt,name=immediate_caller_id,json=immediateCallerId,proto3" json:"immediate_caller_id,omitempty"`
+	Target               *query.Target         `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
+	Position             string                `protobuf:"bytes,4,opt,name=position,proto3" json:"position,omitempty"`
+	Filter               *Filter               `protobuf:"bytes,5,opt,name=filter,proto3" json:"filter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *VStreamRequest) Reset()         { *m = VStreamRequest{} }
+func (m *VStreamRequest) String() string { return proto.CompactTextString(m) }
+func (*VStreamRequest) ProtoMessage()    {}
+func (*VStreamRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{15}
+}
+func (m *VStreamRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamRequest.Unmarshal(m, b)
+}
+func (m *VStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamRequest.Marshal(b, m, deterministic)
+}
+func (dst *VStreamRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamRequest.Merge(dst, src)
+}
+func (m *VStreamRequest) XXX_Size() int {
+	return xxx_messageInfo_VStreamRequest.Size(m)
+}
+func (m *VStreamRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamRequest proto.InternalMessageInfo
+
+func (m *VStreamRequest) GetEffectiveCallerId() *vtrpc.CallerID {
+	if m != nil {
+		return m.EffectiveCallerId
+	}
+	return nil
+}
+
+func (m *VStreamRequest) GetImmediateCallerId() *query.VTGateCallerID {
+	if m != nil {
+		return m.ImmediateCallerId
+	}
+	return nil
+}
+
+func (m *VStreamRequest) GetTarget() *query.Target {
+	if m != nil {
+		return m.Target
+	}
+	return nil
+}
+
+func (m *VStreamRequest) GetPosition() string {
+	if m != nil {
+		return m.Position
+	}
+	return ""
+}
+
+func (m *VStreamRequest) GetFilter() *Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+// VStreamResponse is the response from VStream
+type VStreamResponse struct {
+	Events               []*VEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
+	XXX_unrecognized     []byte    `json:"-"`
+	XXX_sizecache        int32     `json:"-"`
+}
+
+func (m *VStreamResponse) Reset()         { *m = VStreamResponse{} }
+func (m *VStreamResponse) String() string { return proto.CompactTextString(m) }
+func (*VStreamResponse) ProtoMessage()    {}
+func (*VStreamResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{16}
+}
+func (m *VStreamResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamResponse.Unmarshal(m, b)
+}
+func (m *VStreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamResponse.Marshal(b, m, deterministic)
+}
+func (dst *VStreamResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamResponse.Merge(dst, src)
+}
+func (m *VStreamResponse) XXX_Size() int {
+	return xxx_messageInfo_VStreamResponse.Size(m)
+}
+func (m *VStreamResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamResponse proto.InternalMessageInfo
+
+func (m *VStreamResponse) GetEvents() []*VEvent {
+	if m != nil {
+		return m.Events
+	}
+	return nil
+}
+
+// VStreamRowsRequest is the payload for VStreamRows
+type VStreamRowsRequest struct {
+	EffectiveCallerId    *vtrpc.CallerID       `protobuf:"bytes,1,opt,name=effective_caller_id,json=effectiveCallerId,proto3" json:"effective_caller_id,omitempty"`
+	ImmediateCallerId    *query.VTGateCallerID `protobuf:"bytes,2,opt,name=immediate_caller_id,json=immediateCallerId,proto3" json:"immediate_caller_id,omitempty"`
+	Target               *query.Target         `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
+	Query                string                `protobuf:"bytes,4,opt,name=query,proto3" json:"query,omitempty"`
+	Lastpk               *query.QueryResult    `protobuf:"bytes,5,opt,name=lastpk,proto3" json:"lastpk,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
+	XXX_unrecognized     []byte                `json:"-"`
+	XXX_sizecache        int32                 `json:"-"`
+}
+
+func (m *VStreamRowsRequest) Reset()         { *m = VStreamRowsRequest{} }
+func (m *VStreamRowsRequest) String() string { return proto.CompactTextString(m) }
+func (*VStreamRowsRequest) ProtoMessage()    {}
+func (*VStreamRowsRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{17}
+}
+func (m *VStreamRowsRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamRowsRequest.Unmarshal(m, b)
+}
+func (m *VStreamRowsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamRowsRequest.Marshal(b, m, deterministic)
+}
+func (dst *VStreamRowsRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamRowsRequest.Merge(dst, src)
+}
+func (m *VStreamRowsRequest) XXX_Size() int {
+	return xxx_messageInfo_VStreamRowsRequest.Size(m)
+}
+func (m *VStreamRowsRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamRowsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamRowsRequest proto.InternalMessageInfo
+
+func (m *VStreamRowsRequest) GetEffectiveCallerId() *vtrpc.CallerID {
+	if m != nil {
+		return m.EffectiveCallerId
+	}
+	return nil
+}
+
+func (m *VStreamRowsRequest) GetImmediateCallerId() *query.VTGateCallerID {
+	if m != nil {
+		return m.ImmediateCallerId
+	}
+	return nil
+}
+
+func (m *VStreamRowsRequest) GetTarget() *query.Target {
+	if m != nil {
+		return m.Target
+	}
+	return nil
+}
+
+func (m *VStreamRowsRequest) GetQuery() string {
+	if m != nil {
+		return m.Query
+	}
+	return ""
+}
+
+func (m *VStreamRowsRequest) GetLastpk() *query.QueryResult {
+	if m != nil {
+		return m.Lastpk
+	}
+	return nil
+}
+
+// VStreamRowsResponse is the response from VStreamRows
+type VStreamRowsResponse struct {
+	Fields               []*query.Field `protobuf:"bytes,1,rep,name=fields,proto3" json:"fields,omitempty"`
+	Pkfields             []*query.Field `protobuf:"bytes,2,rep,name=pkfields,proto3" json:"pkfields,omitempty"`
+	Gtid                 string         `protobuf:"bytes,3,opt,name=gtid,proto3" json:"gtid,omitempty"`
+	Rows                 []*query.Row   `protobuf:"bytes,4,rep,name=rows,proto3" json:"rows,omitempty"`
+	Lastpk               *query.Row     `protobuf:"bytes,5,opt,name=lastpk,proto3" json:"lastpk,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
+	XXX_unrecognized     []byte         `json:"-"`
+	XXX_sizecache        int32          `json:"-"`
+}
+
+func (m *VStreamRowsResponse) Reset()         { *m = VStreamRowsResponse{} }
+func (m *VStreamRowsResponse) String() string { return proto.CompactTextString(m) }
+func (*VStreamRowsResponse) ProtoMessage()    {}
+func (*VStreamRowsResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_binlogdata_e3df2e837eaa5305, []int{18}
+}
+func (m *VStreamRowsResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamRowsResponse.Unmarshal(m, b)
+}
+func (m *VStreamRowsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamRowsResponse.Marshal(b, m, deterministic)
+}
+func (dst *VStreamRowsResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamRowsResponse.Merge(dst, src)
+}
+func (m *VStreamRowsResponse) XXX_Size() int {
+	return xxx_messageInfo_VStreamRowsResponse.Size(m)
+}
+func (m *VStreamRowsResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamRowsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamRowsResponse proto.InternalMessageInfo
+
+func (m *VStreamRowsResponse) GetFields() []*query.Field {
+	if m != nil {
+		return m.Fields
+	}
+	return nil
+}
+
+func (m *VStreamRowsResponse) GetPkfields() []*query.Field {
+	if m != nil {
+		return m.Pkfields
+	}
+	return nil
+}
+
+func (m *VStreamRowsResponse) GetGtid() string {
+	if m != nil {
+		return m.Gtid
+	}
+	return ""
+}
+
+func (m *VStreamRowsResponse) GetRows() []*query.Row {
+	if m != nil {
+		return m.Rows
+	}
+	return nil
+}
+
+func (m *VStreamRowsResponse) GetLastpk() *query.Row {
+	if m != nil {
+		return m.Lastpk
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Charset)(nil), "binlogdata.Charset")
+	proto.RegisterType((*BinlogTransaction)(nil), "binlogdata.BinlogTransaction")
+	proto.RegisterType((*BinlogTransaction_Statement)(nil), "binlogdata.BinlogTransaction.Statement")
+	proto.RegisterType((*StreamKeyRangeRequest)(nil), "binlogdata.StreamKeyRangeRequest")
+	proto.RegisterType((*StreamKeyRangeResponse)(nil), "binlogdata.StreamKeyRangeResponse")
+	proto.RegisterType((*StreamTablesRequest)(nil), "binlogdata.StreamTablesRequest")
+	proto.RegisterType((*StreamTablesResponse)(nil), "binlogdata.StreamTablesResponse")
+	proto.RegisterType((*Rule)(nil), "binlogdata.Rule")
+	proto.RegisterType((*Filter)(nil), "binlogdata.Filter")
+	proto.RegisterType((*BinlogSource)(nil), "binlogdata.BinlogSource")
+	proto.RegisterType((*RowChange)(nil), "binlogdata.RowChange")
+	proto.RegisterType((*RowEvent)(nil), "binlogdata.RowEvent")
+	proto.RegisterType((*FieldEvent)(nil), "binlogdata.FieldEvent")
+	proto.RegisterType((*ShardGtid)(nil), "binlogdata.ShardGtid")
+	proto.RegisterType((*VGtid)(nil), "binlogdata.VGtid")
+	proto.RegisterType((*VEvent)(nil), "binlogdata.VEvent")
+	proto.RegisterType((*VStreamRequest)(nil), "binlogdata.VStreamRequest")
+	proto.RegisterType((*VStreamResponse)(nil), "binlogdata.VStreamResponse")
+	proto.RegisterType((*VStreamRowsRequest)(nil), "binlogdata.VStreamRowsRequest")
+	proto.RegisterType((*VStreamRowsResponse)(nil), "binlogdata.VStreamRowsResponse")
+	proto.RegisterEnum("binlogdata.OnDDLAction", OnDDLAction_name, OnDDLAction_value)
+	proto.RegisterEnum("binlogdata.VEventType", VEventType_name, VEventType_value)
+	proto.RegisterEnum("binlogdata.BinlogTransaction_Statement_Category", BinlogTransaction_Statement_Category_name, BinlogTransaction_Statement_Category_value)
+}
+
+func init() { proto.RegisterFile("binlogdata.proto", fileDescriptor_binlogdata_e3df2e837eaa5305) }
+
+var fileDescriptor_binlogdata_e3df2e837eaa5305 = []byte{
+	// 1372 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x57, 0xdd, 0x72, 0xdb, 0x54,
+	0x10, 0xae, 0x6d, 0xf9, 0x6f, 0x95, 0x26, 0xca, 0xc9, 0x0f, 0x9e, 0x0c, 0x65, 0x82, 0x06, 0x68,
+	0xc8, 0x0c, 0x4e, 0x31, 0x50, 0xae, 0xa0, 0xe3, 0x1f, 0xd5, 0x75, 0xab, 0xd8, 0xe9, 0xb1, 0x9a,
+	0x32, 0xbd, 0xd1, 0x28, 0xd2, 0x71, 0xa2, 0x89, 0x2c, 0x39, 0xd2, 0xb1, 0x83, 0x1f, 0x80, 0xe1,
+	0x01, 0xb8, 0xe5, 0x05, 0xb8, 0xe3, 0x05, 0xb8, 0x63, 0x78, 0x13, 0xde, 0x83, 0x39, 0x3f, 0x92,
+	0xed, 0xb4, 0xb4, 0x81, 0x19, 0x2e, 0xb8, 0xc9, 0xec, 0xff, 0xd9, 0xfd, 0x76, 0xbd, 0xda, 0x80,
+	0x76, 0xe6, 0x87, 0x41, 0x74, 0xee, 0x39, 0xd4, 0xa9, 0x4f, 0xe2, 0x88, 0x46, 0x08, 0x16, 0x92,
+	0x3d, 0x75, 0x46, 0xe3, 0x89, 0x2b, 0x14, 0x7b, 0xea, 0xd5, 0x94, 0xc4, 0x73, 0xc9, 0xac, 0xd3,
+	0x68, 0x12, 0x2d, 0xbc, 0xf4, 0x63, 0x28, 0xb7, 0x2f, 0x9c, 0x38, 0x21, 0x14, 0xed, 0x42, 0xc9,
+	0x0d, 0x7c, 0x12, 0xd2, 0x5a, 0x6e, 0x3f, 0x77, 0x50, 0xc4, 0x92, 0x43, 0x08, 0x14, 0x37, 0x0a,
+	0xc3, 0x5a, 0x9e, 0x4b, 0x39, 0xcd, 0x6c, 0x13, 0x12, 0xcf, 0x48, 0x5c, 0x2b, 0x08, 0x5b, 0xc1,
+	0xe9, 0x7f, 0x16, 0x60, 0xb3, 0xc5, 0xf3, 0xb0, 0x62, 0x27, 0x4c, 0x1c, 0x97, 0xfa, 0x51, 0x88,
+	0xba, 0x00, 0x09, 0x75, 0x28, 0x19, 0x93, 0x90, 0x26, 0xb5, 0xdc, 0x7e, 0xe1, 0x40, 0x6d, 0xdc,
+	0xaf, 0x2f, 0x55, 0xf0, 0x9a, 0x4b, 0x7d, 0x98, 0xda, 0xe3, 0x25, 0x57, 0xd4, 0x00, 0x95, 0xcc,
+	0x48, 0x48, 0x6d, 0x1a, 0x5d, 0x92, 0xb0, 0xa6, 0xec, 0xe7, 0x0e, 0xd4, 0xc6, 0x66, 0x5d, 0x14,
+	0x68, 0x30, 0x8d, 0xc5, 0x14, 0x18, 0x48, 0x46, 0xef, 0xfd, 0x91, 0x87, 0x6a, 0x16, 0x0d, 0x99,
+	0x50, 0x71, 0x1d, 0x4a, 0xce, 0xa3, 0x78, 0xce, 0xcb, 0x5c, 0x6f, 0x3c, 0xb8, 0x65, 0x22, 0xf5,
+	0xb6, 0xf4, 0xc3, 0x59, 0x04, 0xf4, 0x19, 0x94, 0x5d, 0x81, 0x1e, 0x47, 0x47, 0x6d, 0x6c, 0x2d,
+	0x07, 0x93, 0xc0, 0xe2, 0xd4, 0x06, 0x69, 0x50, 0x48, 0xae, 0x02, 0x0e, 0xd9, 0x1a, 0x66, 0xa4,
+	0xfe, 0x4b, 0x0e, 0x2a, 0x69, 0x5c, 0xb4, 0x05, 0x1b, 0x2d, 0xd3, 0x7e, 0xd1, 0xc7, 0x46, 0x7b,
+	0xd0, 0xed, 0xf7, 0x5e, 0x19, 0x1d, 0xed, 0x0e, 0x5a, 0x83, 0x4a, 0xcb, 0xb4, 0x5b, 0x46, 0xb7,
+	0xd7, 0xd7, 0x72, 0xe8, 0x2e, 0x54, 0x5b, 0xa6, 0xdd, 0x1e, 0x1c, 0x1f, 0xf7, 0x2c, 0x2d, 0x8f,
+	0x36, 0x40, 0x6d, 0x99, 0x36, 0x1e, 0x98, 0x66, 0xab, 0xd9, 0x7e, 0xa6, 0x15, 0xd0, 0x0e, 0x6c,
+	0xb6, 0x4c, 0xbb, 0x73, 0x6c, 0xda, 0x1d, 0xe3, 0x04, 0x1b, 0xed, 0xa6, 0x65, 0x74, 0x34, 0x05,
+	0x01, 0x94, 0x98, 0xb8, 0x63, 0x6a, 0x45, 0x49, 0x0f, 0x0d, 0x4b, 0x2b, 0xc9, 0x70, 0xbd, 0xfe,
+	0xd0, 0xc0, 0x96, 0x56, 0x96, 0xec, 0x8b, 0x93, 0x4e, 0xd3, 0x32, 0xb4, 0x8a, 0x64, 0x3b, 0x86,
+	0x69, 0x58, 0x86, 0x56, 0x7d, 0xaa, 0x54, 0xf2, 0x5a, 0xe1, 0xa9, 0x52, 0x29, 0x68, 0x8a, 0xfe,
+	0x53, 0x0e, 0x76, 0x86, 0x34, 0x26, 0xce, 0xf8, 0x19, 0x99, 0x63, 0x27, 0x3c, 0x27, 0x98, 0x5c,
+	0x4d, 0x49, 0x42, 0xd1, 0x1e, 0x54, 0x26, 0x51, 0xe2, 0x33, 0xec, 0x38, 0xc0, 0x55, 0x9c, 0xf1,
+	0xe8, 0x08, 0xaa, 0x97, 0x64, 0x6e, 0xc7, 0xcc, 0x5e, 0x02, 0x86, 0xea, 0xd9, 0x40, 0x66, 0x91,
+	0x2a, 0x97, 0x92, 0x5a, 0xc6, 0xb7, 0xf0, 0x6e, 0x7c, 0xf5, 0x11, 0xec, 0xde, 0x4c, 0x2a, 0x99,
+	0x44, 0x61, 0x42, 0x90, 0x09, 0x48, 0x38, 0xda, 0x74, 0xd1, 0x5b, 0x9e, 0x9f, 0xda, 0xb8, 0xf7,
+	0xd6, 0x01, 0xc0, 0x9b, 0x67, 0x37, 0x45, 0xfa, 0xf7, 0xb0, 0x25, 0xde, 0xb1, 0x9c, 0xb3, 0x80,
+	0x24, 0xb7, 0x29, 0x7d, 0x17, 0x4a, 0x94, 0x1b, 0xd7, 0xf2, 0xfb, 0x85, 0x83, 0x2a, 0x96, 0xdc,
+	0x3f, 0xad, 0xd0, 0x83, 0xed, 0xd5, 0x97, 0xff, 0x93, 0xfa, 0xbe, 0x04, 0x05, 0x4f, 0x03, 0x82,
+	0xb6, 0xa1, 0x38, 0x76, 0xa8, 0x7b, 0x21, 0xab, 0x11, 0x0c, 0x2b, 0x65, 0xe4, 0x07, 0x94, 0xc4,
+	0xbc, 0x85, 0x55, 0x2c, 0x39, 0xfd, 0x01, 0x94, 0x1e, 0x73, 0x0a, 0x7d, 0x02, 0xc5, 0x78, 0xca,
+	0x6a, 0x15, 0x3f, 0x75, 0x6d, 0x39, 0x01, 0x16, 0x18, 0x0b, 0xb5, 0xfe, 0x73, 0x1e, 0xd6, 0x44,
+	0x42, 0xc3, 0x68, 0x1a, 0xbb, 0x84, 0x21, 0x78, 0x49, 0xe6, 0xc9, 0xc4, 0x71, 0x49, 0x8a, 0x60,
+	0xca, 0xb3, 0x64, 0x92, 0x0b, 0x27, 0xf6, 0xe4, 0xab, 0x82, 0x41, 0x5f, 0x81, 0xca, 0x91, 0xa4,
+	0x36, 0x9d, 0x4f, 0x08, 0xc7, 0x70, 0xbd, 0xb1, 0xbd, 0x18, 0x2a, 0x8e, 0x13, 0xb5, 0xe6, 0x13,
+	0x82, 0x81, 0x66, 0xf4, 0xea, 0x24, 0x2a, 0xb7, 0x98, 0xc4, 0x45, 0xff, 0x8a, 0x2b, 0xfd, 0x3b,
+	0xcc, 0xc0, 0x28, 0xc9, 0x28, 0x4b, 0xb5, 0x0a, 0x38, 0x52, 0x80, 0x50, 0x1d, 0x4a, 0x51, 0x68,
+	0x7b, 0x5e, 0x50, 0x2b, 0xf3, 0x34, 0xdf, 0x5b, 0xb6, 0x1d, 0x84, 0x9d, 0x8e, 0xd9, 0x14, 0x2d,
+	0x29, 0x46, 0x61, 0xc7, 0x0b, 0xf4, 0xe7, 0x50, 0xc5, 0xd1, 0x75, 0xfb, 0x82, 0x27, 0xa0, 0x43,
+	0xe9, 0x8c, 0x8c, 0xa2, 0x98, 0xc8, 0xae, 0x82, 0xdc, 0x7a, 0x38, 0xba, 0xc6, 0x52, 0x83, 0xf6,
+	0xa1, 0xe8, 0x8c, 0xd2, 0xc6, 0xac, 0x9a, 0x08, 0x85, 0xee, 0x40, 0x05, 0x47, 0xd7, 0x7c, 0x53,
+	0xa2, 0x7b, 0x20, 0x10, 0xb1, 0x43, 0x67, 0x9c, 0xc2, 0x5d, 0xe5, 0x92, 0xbe, 0x33, 0x26, 0xe8,
+	0x21, 0xa8, 0x71, 0x74, 0x6d, 0xbb, 0xfc, 0x79, 0x31, 0xb6, 0x6a, 0x63, 0x67, 0xa5, 0x95, 0x69,
+	0x72, 0x18, 0xe2, 0x94, 0x4c, 0xf4, 0xe7, 0x00, 0x8f, 0x7d, 0x12, 0x78, 0xb7, 0x7a, 0xe4, 0x23,
+	0x06, 0x1f, 0x09, 0xbc, 0x34, 0xfe, 0x9a, 0x4c, 0x99, 0x47, 0xc0, 0x52, 0xc7, 0x80, 0x18, 0xb2,
+	0x6e, 0x77, 0xa9, 0xef, 0xfd, 0x8b, 0x19, 0x41, 0xa0, 0x9c, 0x53, 0xdf, 0xe3, 0xc3, 0x51, 0xc5,
+	0x9c, 0xd6, 0x1f, 0x41, 0xf1, 0x94, 0x87, 0x7b, 0x08, 0x2a, 0xb7, 0xb2, 0x99, 0x38, 0x9d, 0xd8,
+	0x95, 0x32, 0xb3, 0xa7, 0x31, 0x24, 0x29, 0x99, 0xe8, 0xbf, 0xe6, 0xa1, 0x74, 0x2a, 0x6a, 0x3c,
+	0x04, 0x85, 0x0f, 0x9f, 0xf8, 0x9e, 0xec, 0x2e, 0xfb, 0x0a, 0x0b, 0x3e, 0x7e, 0xdc, 0x06, 0xbd,
+	0x0f, 0x55, 0xea, 0x8f, 0x49, 0x42, 0x9d, 0xf1, 0x84, 0x67, 0x59, 0xc0, 0x0b, 0xc1, 0x9b, 0x32,
+	0x65, 0x1f, 0x0d, 0x36, 0x32, 0x0a, 0x17, 0x31, 0x12, 0x7d, 0x0e, 0x55, 0xd6, 0x19, 0xfe, 0x8d,
+	0xab, 0x15, 0x79, 0xab, 0xb7, 0x6f, 0xf4, 0x85, 0x3f, 0x8b, 0x2b, 0x71, 0xda, 0xeb, 0xaf, 0x41,
+	0xe5, 0x58, 0x4a, 0x27, 0x31, 0xab, 0xbb, 0xab, 0xb3, 0x9a, 0xf6, 0x0c, 0xc3, 0x68, 0xd1, 0xbf,
+	0xfb, 0x50, 0x9c, 0xf1, 0x94, 0xca, 0xf2, 0x5b, 0xbb, 0x5c, 0x1c, 0x07, 0x45, 0xe8, 0xd1, 0x87,
+	0xb0, 0xe6, 0x4e, 0xe3, 0x98, 0x7f, 0x9c, 0xfd, 0x31, 0xa9, 0x6d, 0xf3, 0xda, 0x54, 0x29, 0xb3,
+	0xfc, 0x31, 0xd1, 0x7f, 0xcc, 0xc3, 0xfa, 0xa9, 0x58, 0x5f, 0xe9, 0xca, 0x7c, 0x04, 0x5b, 0x64,
+	0x34, 0x22, 0x2e, 0xf5, 0x67, 0xc4, 0x76, 0x9d, 0x20, 0x20, 0xb1, 0xed, 0x7b, 0x72, 0xc4, 0x37,
+	0xea, 0xe2, 0x8c, 0x69, 0x73, 0x79, 0xaf, 0x83, 0x37, 0x33, 0x5b, 0x29, 0xf2, 0x90, 0x01, 0x5b,
+	0xfe, 0x78, 0x4c, 0x3c, 0xdf, 0xa1, 0xcb, 0x01, 0xc4, 0x0f, 0x60, 0x47, 0x4e, 0xd3, 0xa9, 0xd5,
+	0x75, 0x28, 0x59, 0x84, 0xc9, 0x3c, 0xb2, 0x30, 0x1f, 0xb3, 0x9f, 0x77, 0x7c, 0x9e, 0x6d, 0xe1,
+	0xbb, 0xd2, 0xd3, 0xe2, 0x42, 0x2c, 0x95, 0x2b, 0x1b, 0x5e, 0xb9, 0xb1, 0xe1, 0x17, 0x9b, 0xa0,
+	0xf8, 0xae, 0x4d, 0xa0, 0x7f, 0x03, 0x1b, 0x19, 0x10, 0x72, 0x83, 0x1f, 0x42, 0x89, 0xf7, 0x26,
+	0x1d, 0x41, 0xf4, 0xfa, 0x18, 0x61, 0x69, 0xa1, 0xff, 0x90, 0x07, 0x94, 0xfa, 0x47, 0xd7, 0xc9,
+	0xff, 0x14, 0xcc, 0x6d, 0x28, 0x72, 0xb9, 0x44, 0x52, 0x30, 0x0c, 0x87, 0xc0, 0x49, 0xe8, 0xe4,
+	0x32, 0x83, 0x51, 0x38, 0x3f, 0x67, 0x7f, 0x31, 0x49, 0xa6, 0x01, 0xc5, 0xd2, 0x42, 0xff, 0x2d,
+	0x07, 0x5b, 0x2b, 0x38, 0x48, 0x2c, 0x17, 0x5b, 0x25, 0xf7, 0xf7, 0x5b, 0x05, 0x1d, 0x40, 0x65,
+	0x72, 0xf9, 0x96, 0xed, 0x93, 0x69, 0xdf, 0xf8, 0xb3, 0xfc, 0x00, 0x94, 0x38, 0xba, 0x4e, 0x6a,
+	0x0a, 0xf7, 0x5c, 0x5e, 0xb5, 0x5c, 0xce, 0xf6, 0xf5, 0x4a, 0x1d, 0x2b, 0xfb, 0x5a, 0x68, 0x0e,
+	0xbf, 0x05, 0x75, 0x69, 0xed, 0xb3, 0xcb, 0xac, 0xd7, 0xed, 0x0f, 0xb0, 0xa1, 0xdd, 0x41, 0x15,
+	0x50, 0x86, 0xd6, 0xe0, 0x44, 0xcb, 0x31, 0xca, 0xf8, 0xce, 0x68, 0x8b, 0x6b, 0x8f, 0x51, 0xb6,
+	0x34, 0x2a, 0x1c, 0xfe, 0x9e, 0x03, 0x58, 0x6c, 0x18, 0xa4, 0x42, 0xf9, 0x45, 0xff, 0x59, 0x7f,
+	0xf0, 0xb2, 0x2f, 0x02, 0x74, 0xad, 0x5e, 0x47, 0xcb, 0xa1, 0x2a, 0x14, 0xc5, 0xf9, 0x98, 0x67,
+	0x2f, 0xc8, 0xdb, 0xb1, 0xc0, 0x0e, 0xcb, 0xec, 0x70, 0x54, 0x50, 0x19, 0x0a, 0xd9, 0x79, 0x28,
+	0xef, 0xc1, 0x12, 0x0b, 0x88, 0x8d, 0x13, 0xb3, 0xd9, 0x36, 0xb4, 0x32, 0x53, 0x64, 0x97, 0x21,
+	0x40, 0x29, 0x3d, 0x0b, 0x99, 0x27, 0x3b, 0x26, 0x81, 0xbd, 0x33, 0xb0, 0x9e, 0x18, 0x58, 0x53,
+	0x99, 0x0c, 0x0f, 0x5e, 0x6a, 0x6b, 0x4c, 0xf6, 0xb8, 0x67, 0x98, 0x1d, 0xed, 0x2e, 0xbb, 0x26,
+	0x9f, 0x18, 0x4d, 0x6c, 0xb5, 0x8c, 0xa6, 0xa5, 0xad, 0x33, 0xcd, 0x29, 0x4f, 0x70, 0xa3, 0xf5,
+	0xe9, 0xab, 0xfb, 0x33, 0x9f, 0x92, 0x24, 0xa9, 0xfb, 0xd1, 0x91, 0xa0, 0x8e, 0xce, 0xa3, 0xa3,
+	0x19, 0x3d, 0xe2, 0xff, 0xa3, 0x1c, 0x2d, 0x7e, 0x08, 0x67, 0x25, 0x2e, 0xf9, 0xe2, 0xaf, 0x00,
+	0x00, 0x00, 0xff, 0xff, 0x59, 0xa0, 0xff, 0x30, 0xff, 0x0c, 0x00, 0x00,
+}
--- a/vendor/vitess.io/vitess/go/vt/proto/vtgate/vtgate.pb.go
+++ b/vendor/vitess.io/vitess/go/vt/proto/vtgate/vtgate.pb.go
@@ -6,6 +6,7 @@ package vtgate // import "vitess.io/vitess/go/vt/proto/vtgate"
 import proto "github.com/golang/protobuf/proto"
 import fmt "fmt"
 import math "math"
+import binlogdata "vitess.io/vitess/go/vt/proto/binlogdata"
 import query "vitess.io/vitess/go/vt/proto/query"
 import topodata "vitess.io/vitess/go/vt/proto/topodata"
 import vtrpc "vitess.io/vitess/go/vt/proto/vtrpc"
@@ -53,7 +54,7 @@ func (x TransactionMode) String() string {
 	return proto.EnumName(TransactionMode_name, int32(x))
 }
 func (TransactionMode) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{0}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{0}
 }

 // CommitOrder is used to designate which of the ShardSessions
@@ -88,7 +89,7 @@ func (x CommitOrder) String() string {
 	return proto.EnumName(CommitOrder_name, int32(x))
 }
 func (CommitOrder) EnumDescriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{1}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{1}
 }

 // Session objects are exchanged like cookies through various
@@ -137,7 +138,7 @@ func (m *Session) Reset()         { *m = Session{} }
 func (m *Session) String() string { return proto.CompactTextString(m) }
 func (*Session) ProtoMessage()    {}
 func (*Session) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{0}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{0}
 }
 func (m *Session) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Session.Unmarshal(m, b)
@@ -239,7 +240,7 @@ func (m *Session_ShardSession) Reset()         { *m = Session_ShardSession{} }
 func (m *Session_ShardSession) String() string { return proto.CompactTextString(m) }
 func (*Session_ShardSession) ProtoMessage()    {}
 func (*Session_ShardSession) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{0, 0}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{0, 0}
 }
 func (m *Session_ShardSession) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_Session_ShardSession.Unmarshal(m, b)
@@ -297,7 +298,7 @@ func (m *ExecuteRequest) Reset()         { *m = ExecuteRequest{} }
 func (m *ExecuteRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteRequest) ProtoMessage()    {}
 func (*ExecuteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{1}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{1}
 }
 func (m *ExecuteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteRequest.Unmarshal(m, b)
@@ -385,7 +386,7 @@ func (m *ExecuteResponse) Reset()         { *m = ExecuteResponse{} }
 func (m *ExecuteResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteResponse) ProtoMessage()    {}
 func (*ExecuteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{2}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{2}
 }
 func (m *ExecuteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteResponse.Unmarshal(m, b)
@@ -455,7 +456,7 @@ func (m *ExecuteShardsRequest) Reset()         { *m = ExecuteShardsRequest{} }
 func (m *ExecuteShardsRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteShardsRequest) ProtoMessage()    {}
 func (*ExecuteShardsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{3}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{3}
 }
 func (m *ExecuteShardsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteShardsRequest.Unmarshal(m, b)
@@ -550,7 +551,7 @@ func (m *ExecuteShardsResponse) Reset()         { *m = ExecuteShardsResponse{} }
 func (m *ExecuteShardsResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteShardsResponse) ProtoMessage()    {}
 func (*ExecuteShardsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{4}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{4}
 }
 func (m *ExecuteShardsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteShardsResponse.Unmarshal(m, b)
@@ -621,7 +622,7 @@ func (m *ExecuteKeyspaceIdsRequest) Reset()         { *m = ExecuteKeyspaceIdsReq
 func (m *ExecuteKeyspaceIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteKeyspaceIdsRequest) ProtoMessage()    {}
 func (*ExecuteKeyspaceIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{5}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{5}
 }
 func (m *ExecuteKeyspaceIdsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteKeyspaceIdsRequest.Unmarshal(m, b)
@@ -716,7 +717,7 @@ func (m *ExecuteKeyspaceIdsResponse) Reset()         { *m = ExecuteKeyspaceIdsRe
 func (m *ExecuteKeyspaceIdsResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteKeyspaceIdsResponse) ProtoMessage()    {}
 func (*ExecuteKeyspaceIdsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{6}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{6}
 }
 func (m *ExecuteKeyspaceIdsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteKeyspaceIdsResponse.Unmarshal(m, b)
@@ -787,7 +788,7 @@ func (m *ExecuteKeyRangesRequest) Reset()         { *m = ExecuteKeyRangesRequest
 func (m *ExecuteKeyRangesRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteKeyRangesRequest) ProtoMessage()    {}
 func (*ExecuteKeyRangesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{7}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{7}
 }
 func (m *ExecuteKeyRangesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteKeyRangesRequest.Unmarshal(m, b)
@@ -882,7 +883,7 @@ func (m *ExecuteKeyRangesResponse) Reset()         { *m = ExecuteKeyRangesRespon
 func (m *ExecuteKeyRangesResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteKeyRangesResponse) ProtoMessage()    {}
 func (*ExecuteKeyRangesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{8}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{8}
 }
 func (m *ExecuteKeyRangesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteKeyRangesResponse.Unmarshal(m, b)
@@ -955,7 +956,7 @@ func (m *ExecuteEntityIdsRequest) Reset()         { *m = ExecuteEntityIdsRequest
 func (m *ExecuteEntityIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteEntityIdsRequest) ProtoMessage()    {}
 func (*ExecuteEntityIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{9}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{9}
 }
 func (m *ExecuteEntityIdsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteEntityIdsRequest.Unmarshal(m, b)
@@ -1054,7 +1055,7 @@ func (m *ExecuteEntityIdsRequest_EntityId) Reset()         { *m = ExecuteEntityI
 func (m *ExecuteEntityIdsRequest_EntityId) String() string { return proto.CompactTextString(m) }
 func (*ExecuteEntityIdsRequest_EntityId) ProtoMessage()    {}
 func (*ExecuteEntityIdsRequest_EntityId) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{9, 0}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{9, 0}
 }
 func (m *ExecuteEntityIdsRequest_EntityId) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteEntityIdsRequest_EntityId.Unmarshal(m, b)
@@ -1114,7 +1115,7 @@ func (m *ExecuteEntityIdsResponse) Reset()         { *m = ExecuteEntityIdsRespon
 func (m *ExecuteEntityIdsResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteEntityIdsResponse) ProtoMessage()    {}
 func (*ExecuteEntityIdsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{10}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{10}
 }
 func (m *ExecuteEntityIdsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteEntityIdsResponse.Unmarshal(m, b)
@@ -1179,7 +1180,7 @@ func (m *ExecuteBatchRequest) Reset()         { *m = ExecuteBatchRequest{} }
 func (m *ExecuteBatchRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchRequest) ProtoMessage()    {}
 func (*ExecuteBatchRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{11}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{11}
 }
 func (m *ExecuteBatchRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchRequest.Unmarshal(m, b)
@@ -1267,7 +1268,7 @@ func (m *ExecuteBatchResponse) Reset()         { *m = ExecuteBatchResponse{} }
 func (m *ExecuteBatchResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchResponse) ProtoMessage()    {}
 func (*ExecuteBatchResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{12}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{12}
 }
 func (m *ExecuteBatchResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchResponse.Unmarshal(m, b)
@@ -1327,7 +1328,7 @@ func (m *BoundShardQuery) Reset()         { *m = BoundShardQuery{} }
 func (m *BoundShardQuery) String() string { return proto.CompactTextString(m) }
 func (*BoundShardQuery) ProtoMessage()    {}
 func (*BoundShardQuery) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{13}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{13}
 }
 func (m *BoundShardQuery) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BoundShardQuery.Unmarshal(m, b)
@@ -1395,7 +1396,7 @@ func (m *ExecuteBatchShardsRequest) Reset()         { *m = ExecuteBatchShardsReq
 func (m *ExecuteBatchShardsRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchShardsRequest) ProtoMessage()    {}
 func (*ExecuteBatchShardsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{14}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{14}
 }
 func (m *ExecuteBatchShardsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchShardsRequest.Unmarshal(m, b)
@@ -1476,7 +1477,7 @@ func (m *ExecuteBatchShardsResponse) Reset()         { *m = ExecuteBatchShardsRe
 func (m *ExecuteBatchShardsResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchShardsResponse) ProtoMessage()    {}
 func (*ExecuteBatchShardsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{15}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{15}
 }
 func (m *ExecuteBatchShardsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchShardsResponse.Unmarshal(m, b)
@@ -1537,7 +1538,7 @@ func (m *BoundKeyspaceIdQuery) Reset()         { *m = BoundKeyspaceIdQuery{} }
 func (m *BoundKeyspaceIdQuery) String() string { return proto.CompactTextString(m) }
 func (*BoundKeyspaceIdQuery) ProtoMessage()    {}
 func (*BoundKeyspaceIdQuery) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{16}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{16}
 }
 func (m *BoundKeyspaceIdQuery) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BoundKeyspaceIdQuery.Unmarshal(m, b)
@@ -1604,7 +1605,7 @@ func (m *ExecuteBatchKeyspaceIdsRequest) Reset()         { *m = ExecuteBatchKeys
 func (m *ExecuteBatchKeyspaceIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchKeyspaceIdsRequest) ProtoMessage()    {}
 func (*ExecuteBatchKeyspaceIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{17}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{17}
 }
 func (m *ExecuteBatchKeyspaceIdsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchKeyspaceIdsRequest.Unmarshal(m, b)
@@ -1685,7 +1686,7 @@ func (m *ExecuteBatchKeyspaceIdsResponse) Reset()         { *m = ExecuteBatchKey
 func (m *ExecuteBatchKeyspaceIdsResponse) String() string { return proto.CompactTextString(m) }
 func (*ExecuteBatchKeyspaceIdsResponse) ProtoMessage()    {}
 func (*ExecuteBatchKeyspaceIdsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{18}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{18}
 }
 func (m *ExecuteBatchKeyspaceIdsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ExecuteBatchKeyspaceIdsResponse.Unmarshal(m, b)
@@ -1749,7 +1750,7 @@ func (m *StreamExecuteRequest) Reset()         { *m = StreamExecuteRequest{} }
 func (m *StreamExecuteRequest) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteRequest) ProtoMessage()    {}
 func (*StreamExecuteRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{19}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{19}
 }
 func (m *StreamExecuteRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteRequest.Unmarshal(m, b)
@@ -1828,7 +1829,7 @@ func (m *StreamExecuteResponse) Reset()         { *m = StreamExecuteResponse{} }
 func (m *StreamExecuteResponse) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteResponse) ProtoMessage()    {}
 func (*StreamExecuteResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{20}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{20}
 }
 func (m *StreamExecuteResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteResponse.Unmarshal(m, b)
@@ -1879,7 +1880,7 @@ func (m *StreamExecuteShardsRequest) Reset()         { *m = StreamExecuteShardsR
 func (m *StreamExecuteShardsRequest) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteShardsRequest) ProtoMessage()    {}
 func (*StreamExecuteShardsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{21}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{21}
 }
 func (m *StreamExecuteShardsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteShardsRequest.Unmarshal(m, b)
@@ -1956,7 +1957,7 @@ func (m *StreamExecuteShardsResponse) Reset()         { *m = StreamExecuteShards
 func (m *StreamExecuteShardsResponse) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteShardsResponse) ProtoMessage()    {}
 func (*StreamExecuteShardsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{22}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{22}
 }
 func (m *StreamExecuteShardsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteShardsResponse.Unmarshal(m, b)
@@ -2008,7 +2009,7 @@ func (m *StreamExecuteKeyspaceIdsRequest) Reset()         { *m = StreamExecuteKe
 func (m *StreamExecuteKeyspaceIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteKeyspaceIdsRequest) ProtoMessage()    {}
 func (*StreamExecuteKeyspaceIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{23}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{23}
 }
 func (m *StreamExecuteKeyspaceIdsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteKeyspaceIdsRequest.Unmarshal(m, b)
@@ -2085,7 +2086,7 @@ func (m *StreamExecuteKeyspaceIdsResponse) Reset()         { *m = StreamExecuteK
 func (m *StreamExecuteKeyspaceIdsResponse) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteKeyspaceIdsResponse) ProtoMessage()    {}
 func (*StreamExecuteKeyspaceIdsResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{24}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{24}
 }
 func (m *StreamExecuteKeyspaceIdsResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteKeyspaceIdsResponse.Unmarshal(m, b)
@@ -2137,7 +2138,7 @@ func (m *StreamExecuteKeyRangesRequest) Reset()         { *m = StreamExecuteKeyR
 func (m *StreamExecuteKeyRangesRequest) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteKeyRangesRequest) ProtoMessage()    {}
 func (*StreamExecuteKeyRangesRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{25}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{25}
 }
 func (m *StreamExecuteKeyRangesRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteKeyRangesRequest.Unmarshal(m, b)
@@ -2214,7 +2215,7 @@ func (m *StreamExecuteKeyRangesResponse) Reset()         { *m = StreamExecuteKey
 func (m *StreamExecuteKeyRangesResponse) String() string { return proto.CompactTextString(m) }
 func (*StreamExecuteKeyRangesResponse) ProtoMessage()    {}
 func (*StreamExecuteKeyRangesResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{26}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{26}
 }
 func (m *StreamExecuteKeyRangesResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_StreamExecuteKeyRangesResponse.Unmarshal(m, b)
@@ -2260,7 +2261,7 @@ func (m *BeginRequest) Reset()         { *m = BeginRequest{} }
 func (m *BeginRequest) String() string { return proto.CompactTextString(m) }
 func (*BeginRequest) ProtoMessage()    {}
 func (*BeginRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{27}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{27}
 }
 func (m *BeginRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BeginRequest.Unmarshal(m, b)
@@ -2307,7 +2308,7 @@ func (m *BeginResponse) Reset()         { *m = BeginResponse{} }
 func (m *BeginResponse) String() string { return proto.CompactTextString(m) }
 func (*BeginResponse) ProtoMessage()    {}
 func (*BeginResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{28}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{28}
 }
 func (m *BeginResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_BeginResponse.Unmarshal(m, b)
@@ -2355,7 +2356,7 @@ func (m *CommitRequest) Reset()         { *m = CommitRequest{} }
 func (m *CommitRequest) String() string { return proto.CompactTextString(m) }
 func (*CommitRequest) ProtoMessage()    {}
 func (*CommitRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{29}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{29}
 }
 func (m *CommitRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitRequest.Unmarshal(m, b)
@@ -2407,7 +2408,7 @@ func (m *CommitResponse) Reset()         { *m = CommitResponse{} }
 func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
 func (*CommitResponse) ProtoMessage()    {}
 func (*CommitResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{30}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{30}
 }
 func (m *CommitResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_CommitResponse.Unmarshal(m, b)
@@ -2443,7 +2444,7 @@ func (m *RollbackRequest) Reset()         { *m = RollbackRequest{} }
 func (m *RollbackRequest) String() string { return proto.CompactTextString(m) }
 func (*RollbackRequest) ProtoMessage()    {}
 func (*RollbackRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{31}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{31}
 }
 func (m *RollbackRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RollbackRequest.Unmarshal(m, b)
@@ -2488,7 +2489,7 @@ func (m *RollbackResponse) Reset()         { *m = RollbackResponse{} }
 func (m *RollbackResponse) String() string { return proto.CompactTextString(m) }
 func (*RollbackResponse) ProtoMessage()    {}
 func (*RollbackResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{32}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{32}
 }
 func (m *RollbackResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_RollbackResponse.Unmarshal(m, b)
@@ -2524,7 +2525,7 @@ func (m *ResolveTransactionRequest) Reset()         { *m = ResolveTransactionReq
 func (m *ResolveTransactionRequest) String() string { return proto.CompactTextString(m) }
 func (*ResolveTransactionRequest) ProtoMessage()    {}
 func (*ResolveTransactionRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{33}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{33}
 }
 func (m *ResolveTransactionRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResolveTransactionRequest.Unmarshal(m, b)
@@ -2580,7 +2581,7 @@ func (m *MessageStreamRequest) Reset()         { *m = MessageStreamRequest{} }
 func (m *MessageStreamRequest) String() string { return proto.CompactTextString(m) }
 func (*MessageStreamRequest) ProtoMessage()    {}
 func (*MessageStreamRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{34}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{34}
 }
 func (m *MessageStreamRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageStreamRequest.Unmarshal(m, b)
@@ -2655,7 +2656,7 @@ func (m *MessageAckRequest) Reset()         { *m = MessageAckRequest{} }
 func (m *MessageAckRequest) String() string { return proto.CompactTextString(m) }
 func (*MessageAckRequest) ProtoMessage()    {}
 func (*MessageAckRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{35}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{35}
 }
 func (m *MessageAckRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageAckRequest.Unmarshal(m, b)
@@ -2719,7 +2720,7 @@ func (m *IdKeyspaceId) Reset()         { *m = IdKeyspaceId{} }
 func (m *IdKeyspaceId) String() string { return proto.CompactTextString(m) }
 func (*IdKeyspaceId) ProtoMessage()    {}
 func (*IdKeyspaceId) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{36}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{36}
 }
 func (m *IdKeyspaceId) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_IdKeyspaceId.Unmarshal(m, b)
@@ -2772,7 +2773,7 @@ func (m *MessageAckKeyspaceIdsRequest) Reset()         { *m = MessageAckKeyspace
 func (m *MessageAckKeyspaceIdsRequest) String() string { return proto.CompactTextString(m) }
 func (*MessageAckKeyspaceIdsRequest) ProtoMessage()    {}
 func (*MessageAckKeyspaceIdsRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{37}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{37}
 }
 func (m *MessageAckKeyspaceIdsRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_MessageAckKeyspaceIdsRequest.Unmarshal(m, b)
@@ -2831,7 +2832,7 @@ func (m *ResolveTransactionResponse) Reset()         { *m = ResolveTransactionRe
 func (m *ResolveTransactionResponse) String() string { return proto.CompactTextString(m) }
 func (*ResolveTransactionResponse) ProtoMessage()    {}
 func (*ResolveTransactionResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{38}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{38}
 }
 func (m *ResolveTransactionResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_ResolveTransactionResponse.Unmarshal(m, b)
@@ -2949,7 +2950,7 @@ func (m *SplitQueryRequest) Reset()         { *m = SplitQueryRequest{} }
 func (m *SplitQueryRequest) String() string { return proto.CompactTextString(m) }
 func (*SplitQueryRequest) ProtoMessage()    {}
 func (*SplitQueryRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{39}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{39}
 }
 func (m *SplitQueryRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SplitQueryRequest.Unmarshal(m, b)
@@ -3038,7 +3039,7 @@ func (m *SplitQueryResponse) Reset()         { *m = SplitQueryResponse{} }
 func (m *SplitQueryResponse) String() string { return proto.CompactTextString(m) }
 func (*SplitQueryResponse) ProtoMessage()    {}
 func (*SplitQueryResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{40}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{40}
 }
 func (m *SplitQueryResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SplitQueryResponse.Unmarshal(m, b)
@@ -3079,7 +3080,7 @@ func (m *SplitQueryResponse_KeyRangePart) Reset()         { *m = SplitQueryRespo
 func (m *SplitQueryResponse_KeyRangePart) String() string { return proto.CompactTextString(m) }
 func (*SplitQueryResponse_KeyRangePart) ProtoMessage()    {}
 func (*SplitQueryResponse_KeyRangePart) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{40, 0}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{40, 0}
 }
 func (m *SplitQueryResponse_KeyRangePart) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SplitQueryResponse_KeyRangePart.Unmarshal(m, b)
@@ -3127,7 +3128,7 @@ func (m *SplitQueryResponse_ShardPart) Reset()         { *m = SplitQueryResponse
 func (m *SplitQueryResponse_ShardPart) String() string { return proto.CompactTextString(m) }
 func (*SplitQueryResponse_ShardPart) ProtoMessage()    {}
 func (*SplitQueryResponse_ShardPart) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{40, 1}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{40, 1}
 }
 func (m *SplitQueryResponse_ShardPart) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SplitQueryResponse_ShardPart.Unmarshal(m, b)
@@ -3180,7 +3181,7 @@ func (m *SplitQueryResponse_Part) Reset()         { *m = SplitQueryResponse_Part
 func (m *SplitQueryResponse_Part) String() string { return proto.CompactTextString(m) }
 func (*SplitQueryResponse_Part) ProtoMessage()    {}
 func (*SplitQueryResponse_Part) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{40, 2}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{40, 2}
 }
 func (m *SplitQueryResponse_Part) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_SplitQueryResponse_Part.Unmarshal(m, b)
@@ -3241,7 +3242,7 @@ func (m *GetSrvKeyspaceRequest) Reset()         { *m = GetSrvKeyspaceRequest{} }
 func (m *GetSrvKeyspaceRequest) String() string { return proto.CompactTextString(m) }
 func (*GetSrvKeyspaceRequest) ProtoMessage()    {}
 func (*GetSrvKeyspaceRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{41}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{41}
 }
 func (m *GetSrvKeyspaceRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetSrvKeyspaceRequest.Unmarshal(m, b)
@@ -3281,7 +3282,7 @@ func (m *GetSrvKeyspaceResponse) Reset()         { *m = GetSrvKeyspaceResponse{}
 func (m *GetSrvKeyspaceResponse) String() string { return proto.CompactTextString(m) }
 func (*GetSrvKeyspaceResponse) ProtoMessage()    {}
 func (*GetSrvKeyspaceResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{42}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{42}
 }
 func (m *GetSrvKeyspaceResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_GetSrvKeyspaceResponse.Unmarshal(m, b)
@@ -3308,6 +3309,111 @@ func (m *GetSrvKeyspaceResponse) GetSrvKeyspace() *topodata.SrvKeyspace {
 	return nil
 }

+// VStreamRequest is the payload for VStream.
+type VStreamRequest struct {
+	CallerId   *vtrpc.CallerID     `protobuf:"bytes,1,opt,name=caller_id,json=callerId,proto3" json:"caller_id,omitempty"`
+	TabletType topodata.TabletType `protobuf:"varint,2,opt,name=tablet_type,json=tabletType,proto3,enum=topodata.TabletType" json:"tablet_type,omitempty"`
+	// position specifies the starting point of the bin log positions
+	// as well as the keyspace-shards to pull events from.
+	// position is of the form 'ks1:0@MySQL56/<mysql_pos>|ks2:-80@MySQL56/<mysql_pos>'.
+	Vgtid                *binlogdata.VGtid  `protobuf:"bytes,3,opt,name=vgtid,proto3" json:"vgtid,omitempty"`
+	Filter               *binlogdata.Filter `protobuf:"bytes,4,opt,name=filter,proto3" json:"filter,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
+	XXX_unrecognized     []byte             `json:"-"`
+	XXX_sizecache        int32              `json:"-"`
+}
+
+func (m *VStreamRequest) Reset()         { *m = VStreamRequest{} }
+func (m *VStreamRequest) String() string { return proto.CompactTextString(m) }
+func (*VStreamRequest) ProtoMessage()    {}
+func (*VStreamRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{43}
+}
+func (m *VStreamRequest) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamRequest.Unmarshal(m, b)
+}
+func (m *VStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamRequest.Marshal(b, m, deterministic)
+}
+func (dst *VStreamRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamRequest.Merge(dst, src)
+}
+func (m *VStreamRequest) XXX_Size() int {
+	return xxx_messageInfo_VStreamRequest.Size(m)
+}
+func (m *VStreamRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamRequest proto.InternalMessageInfo
+
+func (m *VStreamRequest) GetCallerId() *vtrpc.CallerID {
+	if m != nil {
+		return m.CallerId
+	}
+	return nil
+}
+
+func (m *VStreamRequest) GetTabletType() topodata.TabletType {
+	if m != nil {
+		return m.TabletType
+	}
+	return topodata.TabletType_UNKNOWN
+}
+
+func (m *VStreamRequest) GetVgtid() *binlogdata.VGtid {
+	if m != nil {
+		return m.Vgtid
+	}
+	return nil
+}
+
+func (m *VStreamRequest) GetFilter() *binlogdata.Filter {
+	if m != nil {
+		return m.Filter
+	}
+	return nil
+}
+
+// VStreamResponse is streamed by VStream.
+type VStreamResponse struct {
+	Events               []*binlogdata.VEvent `protobuf:"bytes,1,rep,name=events,proto3" json:"events,omitempty"`
+	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
+	XXX_unrecognized     []byte               `json:"-"`
+	XXX_sizecache        int32                `json:"-"`
+}
+
+func (m *VStreamResponse) Reset()         { *m = VStreamResponse{} }
+func (m *VStreamResponse) String() string { return proto.CompactTextString(m) }
+func (*VStreamResponse) ProtoMessage()    {}
+func (*VStreamResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{44}
+}
+func (m *VStreamResponse) XXX_Unmarshal(b []byte) error {
+	return xxx_messageInfo_VStreamResponse.Unmarshal(m, b)
+}
+func (m *VStreamResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	return xxx_messageInfo_VStreamResponse.Marshal(b, m, deterministic)
+}
+func (dst *VStreamResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_VStreamResponse.Merge(dst, src)
+}
+func (m *VStreamResponse) XXX_Size() int {
+	return xxx_messageInfo_VStreamResponse.Size(m)
+}
+func (m *VStreamResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_VStreamResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_VStreamResponse proto.InternalMessageInfo
+
+func (m *VStreamResponse) GetEvents() []*binlogdata.VEvent {
+	if m != nil {
+		return m.Events
+	}
+	return nil
+}
+
 // UpdateStreamRequest is the payload to UpdateStream.
 type UpdateStreamRequest struct {
 	// caller_id identifies the caller. This is the effective caller ID,
@@ -3339,7 +3445,7 @@ func (m *UpdateStreamRequest) Reset()         { *m = UpdateStreamRequest{} }
 func (m *UpdateStreamRequest) String() string { return proto.CompactTextString(m) }
 func (*UpdateStreamRequest) ProtoMessage()    {}
 func (*UpdateStreamRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{43}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{45}
 }
 func (m *UpdateStreamRequest) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateStreamRequest.Unmarshal(m, b)
@@ -3427,7 +3533,7 @@ func (m *UpdateStreamResponse) Reset()         { *m = UpdateStreamResponse{} }
 func (m *UpdateStreamResponse) String() string { return proto.CompactTextString(m) }
 func (*UpdateStreamResponse) ProtoMessage()    {}
 func (*UpdateStreamResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_vtgate_178abacf9cf673c8, []int{44}
+	return fileDescriptor_vtgate_d9799c8e1157b676, []int{46}
 }
 func (m *UpdateStreamResponse) XXX_Unmarshal(b []byte) error {
 	return xxx_messageInfo_UpdateStreamResponse.Unmarshal(m, b)
@@ -3510,137 +3616,144 @@ func init() {
 	proto.RegisterType((*SplitQueryResponse_Part)(nil), "vtgate.SplitQueryResponse.Part")
 	proto.RegisterType((*GetSrvKeyspaceRequest)(nil), "vtgate.GetSrvKeyspaceRequest")
 	proto.RegisterType((*GetSrvKeyspaceResponse)(nil), "vtgate.GetSrvKeyspaceResponse")
+	proto.RegisterType((*VStreamRequest)(nil), "vtgate.VStreamRequest")
+	proto.RegisterType((*VStreamResponse)(nil), "vtgate.VStreamResponse")
 	proto.RegisterType((*UpdateStreamRequest)(nil), "vtgate.UpdateStreamRequest")
 	proto.RegisterType((*UpdateStreamResponse)(nil), "vtgate.UpdateStreamResponse")
 	proto.RegisterEnum("vtgate.TransactionMode", TransactionMode_name, TransactionMode_value)
 	proto.RegisterEnum("vtgate.CommitOrder", CommitOrder_name, CommitOrder_value)
 }

-func init() { proto.RegisterFile("vtgate.proto", fileDescriptor_vtgate_178abacf9cf673c8) }
+func init() { proto.RegisterFile("vtgate.proto", fileDescriptor_vtgate_d9799c8e1157b676) }

-var fileDescriptor_vtgate_178abacf9cf673c8 = []byte{
-	// 1962 bytes of a gzipped FileDescriptorProto
+var fileDescriptor_vtgate_d9799c8e1157b676 = []byte{
+	// 2041 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x5a, 0xcd, 0x8f, 0x23, 0x47,
-	0x15, 0x4f, 0x77, 0xfb, 0xf3, 0xb5, 0xbf, 0xb6, 0xd6, 0xbb, 0xeb, 0x38, 0xc3, 0xce, 0xa4, 0xc3,
-	0x28, 0xce, 0x66, 0xe5, 0x21, 0x0e, 0x04, 0x84, 0x22, 0x85, 0x19, 0xef, 0x10, 0x59, 0xd9, 0xf9,
-	0xa0, 0xec, 0xcd, 0x02, 0x22, 0x6a, 0xf5, 0xd8, 0x25, 0x6f, 0x33, 0x76, 0xb7, 0xd3, 0x55, 0xf6,
-	0x32, 0x1c, 0x50, 0xfe, 0x83, 0x88, 0x03, 0x12, 0x8a, 0x90, 0x10, 0x12, 0x12, 0x27, 0xae, 0x48,
-	0xc0, 0x85, 0x1b, 0x47, 0xc4, 0x89, 0x23, 0x12, 0xff, 0x00, 0x12, 0x7f, 0x01, 0xea, 0xaa, 0xea,
-	0x0f, 0xf7, 0x7c, 0x79, 0x3c, 0x3b, 0x2b, 0xef, 0xc5, 0xea, 0x7a, 0x55, 0xf5, 0xea, 0xbd, 0xdf,
-	0xfb, 0xd5, 0xab, 0xd7, 0xd5, 0x86, 0xc2, 0x8c, 0x0d, 0x2d, 0x46, 0x9a, 0x13, 0xcf, 0x65, 0x2e,
-	0xca, 0x88, 0x56, 0x5d, 0xff, 0x7c, 0x4a, 0xbc, 0x13, 0x21, 0xac, 0x97, 0x98, 0x3b, 0x71, 0x07,
-	0x16, 0xb3, 0x64, 0x5b, 0x9f, 0x31, 0x6f, 0xd2, 0x17, 0x0d, 0xe3, 0xdf, 0x29, 0xc8, 0x76, 0x09,
-	0xa5, 0xb6, 0xeb, 0xa0, 0x4d, 0x28, 0xd9, 0x8e, 0xc9, 0x3c, 0xcb, 0xa1, 0x56, 0x9f, 0xd9, 0xae,
-	0x53, 0x53, 0x36, 0x94, 0x46, 0x0e, 0x17, 0x6d, 0xa7, 0x17, 0x09, 0x51, 0x1b, 0x4a, 0xf4, 0x99,
-	0xe5, 0x0d, 0x4c, 0x2a, 0xe6, 0xd1, 0x9a, 0xba, 0xa1, 0x35, 0xf4, 0xd6, 0x5a, 0x53, 0xda, 0x22,
-	0xf5, 0x35, 0xbb, 0xfe, 0x28, 0xd9, 0xc0, 0x45, 0x1a, 0x6b, 0x51, 0xf4, 0x06, 0xe4, 0xa9, 0xed,
-	0x0c, 0x47, 0xc4, 0x1c, 0x1c, 0xd5, 0x34, 0xbe, 0x4c, 0x4e, 0x08, 0x1e, 0x1d, 0xa1, 0xfb, 0x00,
-	0xd6, 0x94, 0xb9, 0x7d, 0x77, 0x3c, 0xb6, 0x59, 0x2d, 0xc5, 0x7b, 0x63, 0x12, 0xf4, 0x16, 0x14,
-	0x99, 0xe5, 0x0d, 0x09, 0x33, 0x29, 0xf3, 0x6c, 0x67, 0x58, 0x4b, 0x6f, 0x28, 0x8d, 0x3c, 0x2e,
-	0x08, 0x61, 0x97, 0xcb, 0xd0, 0x16, 0x64, 0xdd, 0x09, 0xe3, 0xf6, 0x65, 0x36, 0x94, 0x86, 0xde,
-	0xba, 0xd3, 0x14, 0xa8, 0xec, 0xfe, 0x8c, 0xf4, 0xa7, 0x8c, 0x1c, 0x88, 0x4e, 0x1c, 0x8c, 0x42,
-	0x3b, 0x50, 0x89, 0xf9, 0x6e, 0x8e, 0xdd, 0x01, 0xa9, 0x65, 0x37, 0x94, 0x46, 0xa9, 0x75, 0x2f,
-	0xf0, 0x2c, 0x06, 0xc3, 0x9e, 0x3b, 0x20, 0xb8, 0xcc, 0xe6, 0x05, 0x68, 0x0b, 0x72, 0xcf, 0x2d,
-	0xcf, 0xb1, 0x9d, 0x21, 0xad, 0xe5, 0x38, 0x2a, 0xb7, 0xe5, 0xaa, 0x3f, 0xf0, 0x7f, 0x9f, 0x8a,
-	0x3e, 0x1c, 0x0e, 0x42, 0x1f, 0x41, 0x61, 0xe2, 0x91, 0x08, 0xca, 0xfc, 0x02, 0x50, 0xea, 0x13,
-	0x8f, 0x84, 0x40, 0x6e, 0x43, 0x71, 0xe2, 0x52, 0x16, 0x69, 0x80, 0x05, 0x34, 0x14, 0xfc, 0x29,
-	0x81, 0x8a, 0xfa, 0x4f, 0xa0, 0x10, 0xef, 0x45, 0x9b, 0x90, 0x11, 0x48, 0xf2, 0xf8, 0xeb, 0xad,
-	0xa2, 0x74, 0xa1, 0xc7, 0x85, 0x58, 0x76, 0xfa, 0x74, 0x89, 0xe3, 0x65, 0x0f, 0x6a, 0xea, 0x86,
-	0xd2, 0xd0, 0x70, 0x31, 0x26, 0xed, 0x0c, 0x8c, 0x7f, 0xa8, 0x50, 0x92, 0x90, 0x63, 0xf2, 0xf9,
-	0x94, 0x50, 0x86, 0x1e, 0x42, 0xbe, 0x6f, 0x8d, 0x46, 0xc4, 0xf3, 0x27, 0x89, 0x35, 0xca, 0x4d,
-	0xc1, 0xca, 0x36, 0x97, 0x77, 0x1e, 0xe1, 0x9c, 0x18, 0xd1, 0x19, 0xa0, 0x77, 0x20, 0x2b, 0x9d,
-	0xe3, 0x0b, 0x88, 0xb1, 0x71, 0xdf, 0x70, 0xd0, 0x8f, 0xde, 0x86, 0x34, 0x37, 0x95, 0x33, 0x4a,
-	0x6f, 0xdd, 0x92, 0x86, 0xef, 0xb8, 0x53, 0x67, 0xc0, 0x03, 0x80, 0x45, 0x3f, 0xfa, 0x16, 0xe8,
-	0xcc, 0x3a, 0x1a, 0x11, 0x66, 0xb2, 0x93, 0x09, 0xe1, 0x14, 0x2b, 0xb5, 0xaa, 0xcd, 0x70, 0xa7,
-	0xf4, 0x78, 0x67, 0xef, 0x64, 0x42, 0x30, 0xb0, 0xf0, 0x19, 0x3d, 0x04, 0xe4, 0xb8, 0xcc, 0x4c,
-	0xec, 0x92, 0x34, 0x27, 0x68, 0xc5, 0x71, 0x59, 0x67, 0x6e, 0xa3, 0x6c, 0x42, 0xe9, 0x98, 0x9c,
-	0xd0, 0x89, 0xd5, 0x27, 0x26, 0x67, 0x3f, 0x27, 0x62, 0x1e, 0x17, 0x03, 0x29, 0x47, 0x3d, 0x4e,
-	0xd4, 0xec, 0x22, 0x44, 0x35, 0xbe, 0x54, 0xa0, 0x1c, 0x22, 0x4a, 0x27, 0xae, 0x43, 0x09, 0xda,
-	0x84, 0x34, 0xf1, 0x3c, 0xd7, 0x4b, 0xc0, 0x89, 0x0f, 0xdb, 0xbb, 0xbe, 0x18, 0x8b, 0xde, 0xab,
-	0x60, 0xf9, 0x00, 0x32, 0x1e, 0xa1, 0xd3, 0x11, 0x93, 0x60, 0xa2, 0x38, 0x91, 0x31, 0xef, 0xc1,
-	0x72, 0x84, 0xf1, 0x1f, 0x15, 0xaa, 0xd2, 0x22, 0xee, 0x13, 0x5d, 0x9d, 0x48, 0xd7, 0x21, 0x17,
-	0xc0, 0xcd, 0xc3, 0x9c, 0xc7, 0x61, 0x1b, 0xdd, 0x85, 0x0c, 0x8f, 0x0b, 0xad, 0xa5, 0x37, 0xb4,
-	0x46, 0x1e, 0xcb, 0x56, 0x92, 0x1d, 0x99, 0x6b, 0xb1, 0x23, 0x7b, 0x0e, 0x3b, 0x62, 0x61, 0xcf,
-	0x2d, 0x14, 0xf6, 0x5f, 0x29, 0x70, 0x27, 0x01, 0xf2, 0x4a, 0x04, 0xff, 0x7f, 0x2a, 0xbc, 0x2e,
-	0xed, 0xfa, 0x44, 0x22, 0xdb, 0x79, 0x55, 0x18, 0xf0, 0x26, 0x14, 0xc2, 0x2d, 0x6a, 0x4b, 0x1e,
-	0x14, 0xb0, 0x7e, 0x1c, 0xf9, 0xb1, 0xa2, 0x64, 0xf8, 0x4a, 0x81, 0xfa, 0x59, 0xa0, 0xaf, 0x04,
-	0x23, 0xbe, 0xd0, 0xe0, 0x5e, 0x64, 0x1c, 0xb6, 0x9c, 0x21, 0x79, 0x45, 0xf8, 0xf0, 0x1e, 0xc0,
-	0x31, 0x39, 0x31, 0x3d, 0x6e, 0x32, 0x67, 0x83, 0xef, 0x69, 0x18, 0xeb, 0xc0, 0x1b, 0x9c, 0x3f,
-	0x0e, 0xfc, 0x5a, 0x51, 0x7e, 0xfc, 0x5a, 0x81, 0xda, 0xe9, 0x10, 0xac, 0x04, 0x3b, 0xfe, 0x9c,
-	0x0a, 0xd9, 0xb1, 0xeb, 0x30, 0x9b, 0x9d, 0xbc, 0x32, 0xd9, 0xe2, 0x21, 0x20, 0xc2, 0x2d, 0x36,
-	0xfb, 0xee, 0x68, 0x3a, 0x76, 0x4c, 0xc7, 0x1a, 0x13, 0x59, 0x7c, 0x56, 0x44, 0x4f, 0x9b, 0x77,
-	0xec, 0x5b, 0x63, 0x82, 0x7e, 0x08, 0xb7, 0xe5, 0xe8, 0xb9, 0x14, 0x93, 0xe1, 0xa4, 0x6a, 0x04,
-	0x96, 0x9e, 0x83, 0x44, 0x33, 0x10, 0xe0, 0x5b, 0x42, 0xc9, 0x27, 0xe7, 0xa7, 0xa4, 0xec, 0xb5,
-	0x28, 0x97, 0xbb, 0x9c, 0x72, 0xf9, 0x45, 0x28, 0x57, 0x3f, 0x82, 0x5c, 0x60, 0x34, 0x5a, 0x87,
-	0x14, 0x37, 0x4d, 0xe1, 0xa6, 0xe9, 0x41, 0x01, 0xe9, 0x5b, 0xc4, 0x3b, 0x50, 0x15, 0xd2, 0x33,
-	0x6b, 0x34, 0x25, 0x3c, 0x70, 0x05, 0x2c, 0x1a, 0x68, 0x1d, 0xf4, 0x18, 0x56, 0x3c, 0x56, 0x05,
-	0x0c, 0x51, 0x36, 0x8e, 0xd3, 0x3a, 0x86, 0xd8, 0x4a, 0xd0, 0xfa, 0x9f, 0x2a, 0xdc, 0x96, 0xa6,
-	0xed, 0x58, 0xac, 0xff, 0xec, 0xc6, 0x29, 0xfd, 0x2e, 0x64, 0x7d, 0x6b, 0x6c, 0x42, 0x6b, 0x1a,
-	0xe7, 0xd4, 0x19, 0xa4, 0x0e, 0x46, 0x2c, 0x5b, 0xf0, 0x6e, 0x42, 0xc9, 0xa2, 0x67, 0x14, 0xbb,
-	0x45, 0x8b, 0xbe, 0x8c, 0x4a, 0xf7, 0x2b, 0x25, 0xac, 0x2b, 0x25, 0xa6, 0x37, 0x16, 0xea, 0x6f,
-	0x40, 0x56, 0x04, 0x32, 0x40, 0xf3, 0xae, 0xb4, 0x4d, 0x84, 0xf9, 0xa9, 0xcd, 0x9e, 0x09, 0xd5,
-	0xc1, 0x30, 0xc3, 0x81, 0x32, 0x47, 0x9a, 0xfb, 0xc6, 0xe1, 0x8e, 0xb2, 0x8c, 0x72, 0x85, 0x2c,
-	0xa3, 0x9e, 0x5b, 0x95, 0x6a, 0xf1, 0xaa, 0xd4, 0xf8, 0x53, 0x54, 0x67, 0x71, 0x30, 0x5e, 0x52,
-	0xa5, 0xfd, 0x5e, 0x92, 0x66, 0xe1, 0xdb, 0x70, 0xc2, 0xfb, 0x97, 0x45, 0xb6, 0xab, 0xbe, 0xd8,
-	0x1b, 0xbf, 0x89, 0x6a, 0xa5, 0x39, 0xe0, 0x6e, 0x8c, 0x4b, 0x0f, 0x93, 0x5c, 0x3a, 0x2b, 0x6f,
-	0x84, 0x3c, 0xfa, 0x05, 0x54, 0x39, 0x92, 0x51, 0x86, 0x7f, 0x81, 0x64, 0x4a, 0x16, 0xb8, 0xda,
-	0xa9, 0x02, 0xd7, 0xf8, 0x9b, 0x0a, 0xf7, 0xe3, 0xf0, 0xbc, 0xcc, 0x22, 0xfe, 0x83, 0x24, 0xb9,
-	0xd6, 0xe6, 0xc8, 0x95, 0x80, 0x64, 0x65, 0x19, 0xf6, 0x3b, 0x05, 0xd6, 0xcf, 0x85, 0x70, 0x45,
-	0x68, 0xf6, 0x07, 0x15, 0xaa, 0x5d, 0xe6, 0x11, 0x6b, 0x7c, 0xad, 0xdb, 0x98, 0x90, 0x95, 0xea,
-	0xd5, 0xae, 0x58, 0xb4, 0xc5, 0x43, 0x94, 0x38, 0x4a, 0x52, 0x97, 0x1c, 0x25, 0xe9, 0x85, 0x6e,
-	0xf7, 0x62, 0xb8, 0x66, 0x2e, 0xc6, 0xd5, 0x68, 0xc3, 0x9d, 0x04, 0x50, 0x32, 0x84, 0x51, 0x39,
-	0xa0, 0x5c, 0x5a, 0x0e, 0x7c, 0xa9, 0x42, 0x7d, 0x4e, 0xcb, 0x75, 0xd2, 0xf5, 0xc2, 0xa0, 0xc7,
-	0x53, 0x81, 0x76, 0xee, 0xb9, 0x92, 0xba, 0xe8, 0xb6, 0x23, 0xbd, 0x60, 0xa0, 0xae, 0xbc, 0x49,
-	0x3a, 0xf0, 0xc6, 0x99, 0x80, 0x2c, 0x01, 0xee, 0x6f, 0x55, 0x58, 0x9f, 0xd3, 0x75, 0xed, 0x9c,
-	0xf5, 0x42, 0x10, 0x4e, 0x26, 0xdb, 0xd4, 0xa5, 0xb7, 0x09, 0x37, 0x06, 0xf6, 0x3e, 0x6c, 0x9c,
-	0x0f, 0xd0, 0x12, 0x88, 0xff, 0x51, 0x85, 0xaf, 0x25, 0x15, 0x5e, 0xe7, 0xc5, 0xfe, 0x85, 0xe0,
-	0x3d, 0xff, 0xb6, 0x9e, 0x5a, 0xe2, 0x6d, 0xfd, 0xc6, 0xf0, 0x7f, 0x0c, 0xf7, 0xcf, 0x83, 0x6b,
-	0x09, 0xf4, 0x7f, 0x04, 0x85, 0x1d, 0x32, 0xb4, 0x9d, 0xe5, 0xb0, 0x9e, 0xfb, 0xd6, 0xa2, 0xce,
-	0x7f, 0x6b, 0x31, 0xbe, 0x0b, 0x45, 0xa9, 0x5a, 0xda, 0x15, 0x4b, 0x94, 0xca, 0x25, 0x89, 0xf2,
-	0x0b, 0x05, 0x8a, 0x6d, 0xfe, 0x49, 0xe6, 0xc6, 0x0b, 0x85, 0xbb, 0x90, 0xb1, 0x98, 0x3b, 0xb6,
-	0xfb, 0xf2, 0x63, 0x91, 0x6c, 0x19, 0x15, 0x28, 0x05, 0x16, 0x08, 0xfb, 0x8d, 0x9f, 0x42, 0x19,
-	0xbb, 0xa3, 0xd1, 0x91, 0xd5, 0x3f, 0xbe, 0x69, 0xab, 0x0c, 0x04, 0x95, 0x68, 0x2d, 0xb9, 0xfe,
-	0x67, 0xf0, 0x3a, 0x26, 0xd4, 0x1d, 0xcd, 0x48, 0xac, 0xa4, 0x58, 0xce, 0x12, 0x04, 0xa9, 0x01,
-	0x93, 0xdf, 0x55, 0xf2, 0x98, 0x3f, 0x1b, 0x7f, 0x55, 0xa0, 0xba, 0x47, 0x28, 0xb5, 0x86, 0x44,
-	0x10, 0x6c, 0x39, 0xd5, 0x17, 0xd5, 0x8c, 0x55, 0x48, 0x8b, 0x93, 0x57, 0xec, 0x37, 0xd1, 0x40,
-	0x5b, 0x90, 0x0f, 0x37, 0x1b, 0x3f, 0x93, 0xcf, 0xde, 0x6b, 0xb9, 0x60, 0xaf, 0xf9, 0xd6, 0xc7,
-	0xee, 0x47, 0xf8, 0xb3, 0xf1, 0x4b, 0x05, 0x6e, 0x49, 0xeb, 0xb7, 0x97, 0x8d, 0xcf, 0x45, 0xa6,
-	0x07, 0x6b, 0x6a, 0xd1, 0x9a, 0xe8, 0x3e, 0x68, 0x41, 0x32, 0xd6, 0x5b, 0x05, 0xb9, 0xcb, 0x3e,
-	0xb5, 0x46, 0x53, 0x82, 0xfd, 0x0e, 0x63, 0x0f, 0x0a, 0x9d, 0x58, 0xa5, 0x89, 0xd6, 0x40, 0x0d,
-	0xcd, 0x98, 0x1f, 0xae, 0xda, 0x83, 0xe4, 0x15, 0x85, 0x7a, 0xea, 0x8a, 0xe2, 0x2f, 0x0a, 0xac,
-	0x45, 0x2e, 0x5e, 0xfb, 0x60, 0xba, 0xaa, 0xb7, 0x1f, 0x42, 0xd9, 0x1e, 0x98, 0xa7, 0x8e, 0x21,
-	0xbd, 0x55, 0x0d, 0x58, 0x1c, 0x77, 0x16, 0x17, 0xed, 0x58, 0x8b, 0x1a, 0x6b, 0x50, 0x3f, 0x8b,
-	0xbc, 0x92, 0xda, 0xff, 0x55, 0xe1, 0x56, 0x77, 0x32, 0xb2, 0x99, 0xcc, 0x51, 0x2f, 0xda, 0x9f,
-	0x85, 0x2f, 0xe9, 0xde, 0x84, 0x02, 0xf5, 0xed, 0x90, 0xf7, 0x70, 0xb2, 0xa0, 0xd1, 0xb9, 0x4c,
-	0xdc, 0xc0, 0xf9, 0x71, 0x0a, 0x86, 0x4c, 0x1d, 0xc6, 0x49, 0xa8, 0x61, 0x90, 0x23, 0xa6, 0x0e,
-	0x43, 0xdf, 0x84, 0x7b, 0xce, 0x74, 0x6c, 0x7a, 0xee, 0x73, 0x6a, 0x4e, 0x88, 0x67, 0x72, 0xcd,
-	0xe6, 0xc4, 0xf2, 0x18, 0x4f, 0xf1, 0x1a, 0xbe, 0xed, 0x4c, 0xc7, 0xd8, 0x7d, 0x4e, 0x0f, 0x89,
-	0xc7, 0x17, 0x3f, 0xb4, 0x3c, 0x86, 0xbe, 0x07, 0x79, 0x6b, 0x34, 0x74, 0x3d, 0x9b, 0x3d, 0x1b,
-	0xcb, 0x8b, 0x37, 0x43, 0x9a, 0x79, 0x0a, 0x99, 0xe6, 0x76, 0x30, 0x12, 0x47, 0x93, 0xd0, 0xbb,
-	0x80, 0xa6, 0x94, 0x98, 0xc2, 0x38, 0xb1, 0xe8, 0xac, 0x25, 0x6f, 0xe1, 0xca, 0x53, 0x4a, 0x22,
-	0x35, 0x9f, 0xb6, 0x8c, 0xbf, 0x6b, 0x80, 0xe2, 0x7a, 0x65, 0x8e, 0xfe, 0x36, 0x64, 0xf8, 0x7c,
-	0x5a, 0x53, 0x78, 0x6c, 0xd7, 0xc3, 0x0c, 0x75, 0x6a, 0x6c, 0xd3, 0x37, 0x1b, 0xcb, 0xe1, 0xf5,
-	0xcf, 0xa0, 0x10, 0xec, 0x54, 0xee, 0x4e, 0x3c, 0x1a, 0xca, 0x85, 0xa7, 0xab, 0xba, 0xc0, 0xe9,
-	0x5a, 0xff, 0x08, 0xf2, 0xbc, 0xaa, 0xbb, 0x54, 0x77, 0x54, 0x8b, 0xaa, 0xf1, 0x5a, 0xb4, 0xfe,
-	0x2f, 0x05, 0x52, 0x7c, 0xf2, 0xc2, 0x2f, 0xbf, 0x7b, 0xfc, 0x7d, 0x41, 0x58, 0x29, 0xa2, 0x27,
-	0x92, 0xf6, 0xdb, 0x17, 0x40, 0x12, 0x87, 0x00, 0x17, 0x8e, 0xe3, 0x80, 0xb4, 0x01, 0xc4, 0x9f,
-	0x1b, 0xb8, 0x2a, 0xc1, 0xc3, 0xaf, 0x5f, 0xa0, 0x2a, 0x74, 0x17, 0xe7, 0x69, 0xe8, 0x39, 0x82,
-	0x14, 0xb5, 0x7f, 0x2e, 0xb2, 0xa4, 0x86, 0xf9, 0xb3, 0xf1, 0x3e, 0xdc, 0xf9, 0x98, 0xb0, 0xae,
-	0x37, 0x0b, 0xb6, 0x5b, 0xb0, 0x7d, 0x2e, 0x80, 0xc9, 0xc0, 0x70, 0x37, 0x39, 0x49, 0x32, 0xe0,
-	0x3b, 0x50, 0xa0, 0xde, 0xcc, 0x9c, 0x9b, 0xe9, 0x57, 0x25, 0x61, 0x78, 0xe2, 0x93, 0x74, 0x1a,
-	0x35, 0x8c, 0xdf, 0xab, 0x70, 0xfb, 0xc9, 0x64, 0x60, 0xb1, 0x55, 0x3f, 0x3f, 0x96, 0x2c, 0xd5,
-	0xd6, 0x20, 0xcf, 0xec, 0x31, 0xa1, 0xcc, 0x1a, 0x4f, 0xe4, 0x4e, 0x8e, 0x04, 0x3e, 0xaf, 0xc8,
-	0x8c, 0x38, 0x4c, 0x5e, 0x40, 0x06, 0xbc, 0xda, 0xf5, 0x65, 0x3d, 0xf7, 0x98, 0x38, 0x58, 0xf4,
-	0x1b, 0xc7, 0x50, 0x9d, 0x47, 0x49, 0x02, 0xdf, 0x08, 0x14, 0xcc, 0x57, 0x6d, 0xb2, 0xd8, 0xf3,
-	0x7b, 0xa4, 0x06, 0xf4, 0x0e, 0x54, 0xfc, 0xf2, 0x6d, 0x4c, 0xcc, 0xc8, 0x1e, 0xf1, 0x0f, 0x89,
-	0xb2, 0x90, 0xf7, 0x02, 0xf1, 0x83, 0x47, 0x50, 0x4e, 0xfc, 0xb5, 0x04, 0x95, 0x41, 0x7f, 0xb2,
-	0xdf, 0x3d, 0xdc, 0x6d, 0x77, 0xbe, 0xdf, 0xd9, 0x7d, 0x54, 0x79, 0x0d, 0x01, 0x64, 0xba, 0x9d,
-	0xfd, 0x8f, 0x1f, 0xef, 0x56, 0x14, 0x94, 0x87, 0xf4, 0xde, 0x93, 0xc7, 0xbd, 0x4e, 0x45, 0xf5,
-	0x1f, 0x7b, 0x4f, 0x0f, 0x0e, 0xdb, 0x15, 0xed, 0xc1, 0x87, 0xa0, 0x8b, 0x5a, 0xe8, 0xc0, 0x1b,
-	0x10, 0xcf, 0x9f, 0xb0, 0x7f, 0x80, 0xf7, 0xb6, 0x1f, 0x57, 0x5e, 0x43, 0x59, 0xd0, 0x0e, 0xb1,
-	0x3f, 0x33, 0x07, 0xa9, 0xc3, 0x83, 0x6e, 0xaf, 0xa2, 0xa2, 0x12, 0xc0, 0xf6, 0x93, 0xde, 0x41,
-	0xfb, 0x60, 0x6f, 0xaf, 0xd3, 0xab, 0x68, 0x3b, 0x1f, 0x40, 0xd9, 0x76, 0x9b, 0x33, 0x9b, 0x11,
-	0x4a, 0xc5, 0x9f, 0x83, 0x7e, 0xfc, 0x96, 0x6c, 0xd9, 0xee, 0x96, 0x78, 0xda, 0x1a, 0xba, 0x5b,
-	0x33, 0xb6, 0xc5, 0x7b, 0xb7, 0xc4, 0xa6, 0x38, 0xca, 0xf0, 0xd6, 0xfb, 0xff, 0x0f, 0x00, 0x00,
-	0xff, 0xff, 0x43, 0xd4, 0xfe, 0x66, 0x8a, 0x24, 0x00, 0x00,
+	0x15, 0x4f, 0x77, 0xfb, 0xf3, 0xf9, 0x73, 0x6b, 0xbc, 0x1b, 0xc7, 0x19, 0x76, 0x26, 0x1d, 0x46,
+	0xeb, 0x6c, 0x56, 0x1e, 0xe2, 0x40, 0x40, 0x28, 0x28, 0xcc, 0x78, 0x27, 0x2b, 0x2b, 0x3b, 0x1f,
+	0x94, 0xbd, 0xb3, 0x80, 0x88, 0x5a, 0x3d, 0x76, 0xe1, 0x6d, 0xc6, 0xee, 0x76, 0xba, 0xca, 0x5e,
+	0x86, 0x03, 0xca, 0x7f, 0x10, 0x71, 0x40, 0x42, 0x11, 0x12, 0x42, 0x42, 0xe2, 0xc4, 0x15, 0x09,
+	0xb8, 0x70, 0x43, 0xe2, 0x82, 0x38, 0x71, 0x44, 0xe2, 0x1f, 0x40, 0xe2, 0x2f, 0x40, 0x5d, 0x55,
+	0xfd, 0xe1, 0x9e, 0x2f, 0x8f, 0x67, 0x67, 0xe5, 0xbd, 0x58, 0x5d, 0xf5, 0x5e, 0x55, 0xbd, 0xf7,
+	0x7b, 0xbf, 0x7a, 0xf5, 0xba, 0xdc, 0x90, 0x9f, 0xb2, 0x81, 0xc9, 0x48, 0x63, 0xec, 0x3a, 0xcc,
+	0x41, 0x29, 0xd1, 0xaa, 0x95, 0x8f, 0x2c, 0x7b, 0xe8, 0x0c, 0xfa, 0x26, 0x33, 0x85, 0xa4, 0x96,
+	0xfb, 0x6c, 0x42, 0xdc, 0x13, 0xd9, 0x28, 0x32, 0x67, 0xec, 0x44, 0x85, 0x53, 0xe6, 0x8e, 0x7b,
+	0xa2, 0xa1, 0xff, 0x3b, 0x01, 0xe9, 0x0e, 0xa1, 0xd4, 0x72, 0x6c, 0xb4, 0x01, 0x45, 0xcb, 0x36,
+	0x98, 0x6b, 0xda, 0xd4, 0xec, 0x31, 0xcb, 0xb1, 0xab, 0xca, 0xba, 0x52, 0xcf, 0xe0, 0x82, 0x65,
+	0x77, 0xc3, 0x4e, 0xd4, 0x82, 0x22, 0x7d, 0x66, 0xba, 0x7d, 0x83, 0x8a, 0x71, 0xb4, 0xaa, 0xae,
+	0x6b, 0xf5, 0x5c, 0x73, 0xb5, 0x21, 0xad, 0x93, 0xf3, 0x35, 0x3a, 0x9e, 0x96, 0x6c, 0xe0, 0x02,
+	0x8d, 0xb4, 0x28, 0x7a, 0x13, 0xb2, 0xd4, 0xb2, 0x07, 0x43, 0x62, 0xf4, 0x8f, 0xaa, 0x1a, 0x5f,
+	0x26, 0x23, 0x3a, 0x1e, 0x1e, 0xa1, 0xbb, 0x00, 0xe6, 0x84, 0x39, 0x3d, 0x67, 0x34, 0xb2, 0x58,
+	0x35, 0xc1, 0xa5, 0x91, 0x1e, 0xf4, 0x36, 0x14, 0x98, 0xe9, 0x0e, 0x08, 0x33, 0x28, 0x73, 0x2d,
+	0x7b, 0x50, 0x4d, 0xae, 0x2b, 0xf5, 0x2c, 0xce, 0x8b, 0xce, 0x0e, 0xef, 0x43, 0x9b, 0x90, 0x76,
+	0xc6, 0x8c, 0xdb, 0x97, 0x5a, 0x57, 0xea, 0xb9, 0xe6, 0xed, 0x86, 0x40, 0x65, 0xe7, 0xa7, 0xa4,
+	0x37, 0x61, 0x64, 0x5f, 0x08, 0xb1, 0xaf, 0x85, 0xb6, 0xa1, 0x1c, 0xf1, 0xdd, 0x18, 0x39, 0x7d,
+	0x52, 0x4d, 0xaf, 0x2b, 0xf5, 0x62, 0xf3, 0x75, 0xdf, 0xb3, 0x08, 0x0c, 0xbb, 0x4e, 0x9f, 0xe0,
+	0x12, 0x9b, 0xed, 0x40, 0x9b, 0x90, 0x79, 0x6e, 0xba, 0xb6, 0x65, 0x0f, 0x68, 0x35, 0xc3, 0x51,
+	0x59, 0x91, 0xab, 0x7e, 0xcf, 0xfb, 0x7d, 0x2a, 0x64, 0x38, 0x50, 0x42, 0x1f, 0x41, 0x7e, 0xec,
+	0x92, 0x10, 0xca, 0xec, 0x1c, 0x50, 0xe6, 0xc6, 0x2e, 0x09, 0x80, 0xdc, 0x82, 0xc2, 0xd8, 0xa1,
+	0x2c, 0x9c, 0x01, 0xe6, 0x98, 0x21, 0xef, 0x0d, 0xf1, 0xa7, 0xa8, 0xfd, 0x08, 0xf2, 0x51, 0x29,
+	0xda, 0x80, 0x94, 0x40, 0x92, 0xc7, 0x3f, 0xd7, 0x2c, 0x48, 0x17, 0xba, 0xbc, 0x13, 0x4b, 0xa1,
+	0x47, 0x97, 0x28, 0x5e, 0x56, 0xbf, 0xaa, 0xae, 0x2b, 0x75, 0x0d, 0x17, 0x22, 0xbd, 0xed, 0xbe,
+	0xfe, 0x0f, 0x15, 0x8a, 0x12, 0x72, 0x4c, 0x3e, 0x9b, 0x10, 0xca, 0xd0, 0x03, 0xc8, 0xf6, 0xcc,
+	0xe1, 0x90, 0xb8, 0xde, 0x20, 0xb1, 0x46, 0xa9, 0x21, 0x58, 0xd9, 0xe2, 0xfd, 0xed, 0x87, 0x38,
+	0x23, 0x34, 0xda, 0x7d, 0xf4, 0x0e, 0xa4, 0xa5, 0x73, 0x7c, 0x01, 0xa1, 0x1b, 0xf5, 0x0d, 0xfb,
+	0x72, 0x74, 0x0f, 0x92, 0xdc, 0x54, 0xce, 0xa8, 0x5c, 0xf3, 0x96, 0x34, 0x7c, 0xdb, 0x99, 0xd8,
+	0x7d, 0x1e, 0x00, 0x2c, 0xe4, 0xe8, 0x1b, 0x90, 0x63, 0xe6, 0xd1, 0x90, 0x30, 0x83, 0x9d, 0x8c,
+	0x09, 0xa7, 0x58, 0xb1, 0x59, 0x69, 0x04, 0x3b, 0xa5, 0xcb, 0x85, 0xdd, 0x93, 0x31, 0xc1, 0xc0,
+	0x82, 0x67, 0xf4, 0x00, 0x90, 0xed, 0x30, 0x23, 0xb6, 0x4b, 0x92, 0x9c, 0xa0, 0x65, 0xdb, 0x61,
+	0xed, 0x99, 0x8d, 0xb2, 0x01, 0xc5, 0x63, 0x72, 0x42, 0xc7, 0x66, 0x8f, 0x18, 0x9c, 0xfd, 0x9c,
+	0x88, 0x59, 0x5c, 0xf0, 0x7b, 0x39, 0xea, 0x51, 0xa2, 0xa6, 0xe7, 0x21, 0xaa, 0xfe, 0x85, 0x02,
+	0xa5, 0x00, 0x51, 0x3a, 0x76, 0x6c, 0x4a, 0xd0, 0x06, 0x24, 0x89, 0xeb, 0x3a, 0x6e, 0x0c, 0x4e,
+	0x7c, 0xd0, 0xda, 0xf1, 0xba, 0xb1, 0x90, 0x5e, 0x05, 0xcb, 0xfb, 0x90, 0x72, 0x09, 0x9d, 0x0c,
+	0x99, 0x04, 0x13, 0x45, 0x89, 0x8c, 0xb9, 0x04, 0x4b, 0x0d, 0xfd, 0x3f, 0x2a, 0x54, 0xa4, 0x45,
+	0xdc, 0x27, 0xba, 0x3c, 0x91, 0xae, 0x41, 0xc6, 0x87, 0x9b, 0x87, 0x39, 0x8b, 0x83, 0x36, 0xba,
+	0x03, 0x29, 0x1e, 0x17, 0x5a, 0x4d, 0xae, 0x6b, 0xf5, 0x2c, 0x96, 0xad, 0x38, 0x3b, 0x52, 0xd7,
+	0x62, 0x47, 0xfa, 0x1c, 0x76, 0x44, 0xc2, 0x9e, 0x99, 0x2b, 0xec, 0xbf, 0x54, 0xe0, 0x76, 0x0c,
+	0xe4, 0xa5, 0x08, 0xfe, 0xff, 0x54, 0x78, 0x43, 0xda, 0xf5, 0x89, 0x44, 0xb6, 0xfd, 0xaa, 0x30,
+	0xe0, 0x2d, 0xc8, 0x07, 0x5b, 0xd4, 0x92, 0x3c, 0xc8, 0xe3, 0xdc, 0x71, 0xe8, 0xc7, 0x92, 0x92,
+	0xe1, 0x4b, 0x05, 0x6a, 0x67, 0x81, 0xbe, 0x14, 0x8c, 0xf8, 0x5c, 0x83, 0xd7, 0x43, 0xe3, 0xb0,
+	0x69, 0x0f, 0xc8, 0x2b, 0xc2, 0x87, 0xf7, 0x00, 0x8e, 0xc9, 0x89, 0xe1, 0x72, 0x93, 0x39, 0x1b,
+	0x3c, 0x4f, 0x83, 0x58, 0xfb, 0xde, 0xe0, 0xec, 0xb1, 0xef, 0xd7, 0x92, 0xf2, 0xe3, 0x57, 0x0a,
+	0x54, 0x4f, 0x87, 0x60, 0x29, 0xd8, 0xf1, 0xa7, 0x44, 0xc0, 0x8e, 0x1d, 0x9b, 0x59, 0xec, 0xe4,
+	0x95, 0xc9, 0x16, 0x0f, 0x00, 0x11, 0x6e, 0xb1, 0xd1, 0x73, 0x86, 0x93, 0x91, 0x6d, 0xd8, 0xe6,
+	0x88, 0xc8, 0xe2, 0xb3, 0x2c, 0x24, 0x2d, 0x2e, 0xd8, 0x33, 0x47, 0x04, 0x7d, 0x1f, 0x56, 0xa4,
+	0xf6, 0x4c, 0x8a, 0x49, 0x71, 0x52, 0xd5, 0x7d, 0x4b, 0xcf, 0x41, 0xa2, 0xe1, 0x77, 0xe0, 0x5b,
+	0x62, 0x92, 0x4f, 0xce, 0x4f, 0x49, 0xe9, 0x6b, 0x51, 0x2e, 0x73, 0x39, 0xe5, 0xb2, 0xf3, 0x50,
+	0xae, 0x76, 0x04, 0x19, 0xdf, 0x68, 0xb4, 0x06, 0x09, 0x6e, 0x9a, 0xc2, 0x4d, 0xcb, 0xf9, 0x05,
+	0xa4, 0x67, 0x11, 0x17, 0xa0, 0x0a, 0x24, 0xa7, 0xe6, 0x70, 0x42, 0x78, 0xe0, 0xf2, 0x58, 0x34,
+	0xd0, 0x1a, 0xe4, 0x22, 0x58, 0xf1, 0x58, 0xe5, 0x31, 0x84, 0xd9, 0x38, 0x4a, 0xeb, 0x08, 0x62,
+	0x4b, 0x41, 0xeb, 0x7f, 0xaa, 0xb0, 0x22, 0x4d, 0xdb, 0x36, 0x59, 0xef, 0xd9, 0x8d, 0x53, 0xfa,
+	0x5d, 0x48, 0x7b, 0xd6, 0x58, 0x84, 0x56, 0x35, 0xce, 0xa9, 0x33, 0x48, 0xed, 0x6b, 0x2c, 0x5a,
+	0xf0, 0x6e, 0x40, 0xd1, 0xa4, 0x67, 0x14, 0xbb, 0x05, 0x93, 0xbe, 0x8c, 0x4a, 0xf7, 0x4b, 0x25,
+	0xa8, 0x2b, 0x25, 0xa6, 0x37, 0x16, 0xea, 0xaf, 0x41, 0x5a, 0x04, 0xd2, 0x47, 0xf3, 0x8e, 0xb4,
+	0x4d, 0x84, 0xf9, 0xa9, 0xc5, 0x9e, 0x89, 0xa9, 0x7d, 0x35, 0xdd, 0x86, 0x12, 0x47, 0x9a, 0xfb,
+	0xc6, 0xe1, 0x0e, 0xb3, 0x8c, 0x72, 0x85, 0x2c, 0xa3, 0x9e, 0x5b, 0x95, 0x6a, 0xd1, 0xaa, 0x54,
+	0xff, 0x63, 0x58, 0x67, 0x71, 0x30, 0x5e, 0x52, 0xa5, 0xfd, 0x5e, 0x9c, 0x66, 0xc1, 0xdb, 0x70,
+	0xcc, 0xfb, 0x97, 0x45, 0xb6, 0xab, 0xbe, 0xd8, 0xeb, 0xbf, 0x0e, 0x6b, 0xa5, 0x19, 0xe0, 0x6e,
+	0x8c, 0x4b, 0x0f, 0xe2, 0x5c, 0x3a, 0x2b, 0x6f, 0x04, 0x3c, 0xfa, 0x39, 0x54, 0x38, 0x92, 0x61,
+	0x86, 0x7f, 0x81, 0x64, 0x8a, 0x17, 0xb8, 0xda, 0xa9, 0x02, 0x57, 0xff, 0xab, 0x0a, 0x77, 0xa3,
+	0xf0, 0xbc, 0xcc, 0x22, 0xfe, 0x83, 0x38, 0xb9, 0x56, 0x67, 0xc8, 0x15, 0x83, 0x64, 0x69, 0x19,
+	0xf6, 0x5b, 0x05, 0xd6, 0xce, 0x85, 0x70, 0x49, 0x68, 0xf6, 0x7b, 0x15, 0x2a, 0x1d, 0xe6, 0x12,
+	0x73, 0x74, 0xad, 0xdb, 0x98, 0x80, 0x95, 0xea, 0xd5, 0xae, 0x58, 0xb4, 0xf9, 0x43, 0x14, 0x3b,
+	0x4a, 0x12, 0x97, 0x1c, 0x25, 0xc9, 0xb9, 0x6e, 0xf7, 0x22, 0xb8, 0xa6, 0x2e, 0xc6, 0x55, 0x6f,
+	0xc1, 0xed, 0x18, 0x50, 0x32, 0x84, 0x61, 0x39, 0xa0, 0x5c, 0x5a, 0x0e, 0x7c, 0xa1, 0x42, 0x6d,
+	0x66, 0x96, 0xeb, 0xa4, 0xeb, 0xb9, 0x41, 0x8f, 0xa6, 0x02, 0xed, 0xdc, 0x73, 0x25, 0x71, 0xd1,
+	0x6d, 0x47, 0x72, 0xce, 0x40, 0x5d, 0x79, 0x93, 0xb4, 0xe1, 0xcd, 0x33, 0x01, 0x59, 0x00, 0xdc,
+	0xdf, 0xa8, 0xb0, 0x36, 0x33, 0xd7, 0xb5, 0x73, 0xd6, 0x0b, 0x41, 0x38, 0x9e, 0x6c, 0x13, 0x97,
+	0xde, 0x26, 0xdc, 0x18, 0xd8, 0x7b, 0xb0, 0x7e, 0x3e, 0x40, 0x0b, 0x20, 0xfe, 0x07, 0x15, 0xbe,
+	0x12, 0x9f, 0xf0, 0x3a, 0x2f, 0xf6, 0x2f, 0x04, 0xef, 0xd9, 0xb7, 0xf5, 0xc4, 0x02, 0x6f, 0xeb,
+	0x37, 0x86, 0xff, 0x63, 0xb8, 0x7b, 0x1e, 0x5c, 0x0b, 0xa0, 0xff, 0x03, 0xc8, 0x6f, 0x93, 0x81,
+	0x65, 0x2f, 0x86, 0xf5, 0xcc, 0x7f, 0x2d, 0xea, 0xec, 0x7f, 0x2d, 0xfa, 0xb7, 0xa1, 0x20, 0xa7,
+	0x96, 0x76, 0x45, 0x12, 0xa5, 0x72, 0x49, 0xa2, 0xfc, 0x5c, 0x81, 0x42, 0x8b, 0xff, 0x25, 0x73,
+	0xe3, 0x85, 0xc2, 0x1d, 0x48, 0x99, 0xcc, 0x19, 0x59, 0x3d, 0xf9, 0x67, 0x91, 0x6c, 0xe9, 0x65,
+	0x28, 0xfa, 0x16, 0x08, 0xfb, 0xf5, 0x9f, 0x40, 0x09, 0x3b, 0xc3, 0xe1, 0x91, 0xd9, 0x3b, 0xbe,
+	0x69, 0xab, 0x74, 0x04, 0xe5, 0x70, 0x2d, 0xb9, 0xfe, 0xa7, 0xf0, 0x06, 0x26, 0xd4, 0x19, 0x4e,
+	0x49, 0xa4, 0xa4, 0x58, 0xcc, 0x12, 0x04, 0x89, 0x3e, 0x93, 0xff, 0xab, 0x64, 0x31, 0x7f, 0xd6,
+	0xff, 0xa2, 0x40, 0x65, 0x97, 0x50, 0x6a, 0x0e, 0x88, 0x20, 0xd8, 0x62, 0x53, 0x5f, 0x54, 0x33,
+	0x56, 0x20, 0x29, 0x4e, 0x5e, 0xb1, 0xdf, 0x44, 0x03, 0x6d, 0x42, 0x36, 0xd8, 0x6c, 0xfc, 0x4c,
+	0x3e, 0x7b, 0xaf, 0x65, 0xfc, 0xbd, 0xe6, 0x59, 0x1f, 0xb9, 0x1f, 0xe1, 0xcf, 0xfa, 0x2f, 0x14,
+	0xb8, 0x25, 0xad, 0xdf, 0x5a, 0x34, 0x3e, 0x17, 0x99, 0xee, 0xaf, 0xa9, 0x85, 0x6b, 0xa2, 0xbb,
+	0xa0, 0xf9, 0xc9, 0x38, 0xd7, 0xcc, 0xcb, 0x5d, 0x76, 0x68, 0x0e, 0x27, 0x04, 0x7b, 0x02, 0x7d,
+	0x17, 0xf2, 0xed, 0x48, 0xa5, 0x89, 0x56, 0x41, 0x0d, 0xcc, 0x98, 0x55, 0x57, 0xad, 0x7e, 0xfc,
+	0x8a, 0x42, 0x3d, 0x75, 0x45, 0xf1, 0x67, 0x05, 0x56, 0x43, 0x17, 0xaf, 0x7d, 0x30, 0x5d, 0xd5,
+	0xdb, 0x0f, 0xa1, 0x64, 0xf5, 0x8d, 0x53, 0xc7, 0x50, 0xae, 0x59, 0xf1, 0x59, 0x1c, 0x75, 0x16,
+	0x17, 0xac, 0x48, 0x8b, 0xea, 0xab, 0x50, 0x3b, 0x8b, 0xbc, 0x92, 0xda, 0xff, 0x55, 0xe1, 0x56,
+	0x67, 0x3c, 0xb4, 0x98, 0xcc, 0x51, 0x2f, 0xda, 0x9f, 0xb9, 0x2f, 0xe9, 0xde, 0x82, 0x3c, 0xf5,
+	0xec, 0x90, 0xf7, 0x70, 0xb2, 0xa0, 0xc9, 0xf1, 0x3e, 0x71, 0x03, 0xe7, 0xc5, 0xc9, 0x57, 0x99,
+	0xd8, 0x8c, 0x93, 0x50, 0xc3, 0x20, 0x35, 0x26, 0x36, 0x43, 0x5f, 0x87, 0xd7, 0xed, 0xc9, 0xc8,
+	0x70, 0x9d, 0xe7, 0xd4, 0x18, 0x13, 0xd7, 0xe0, 0x33, 0x1b, 0x63, 0xd3, 0x65, 0x3c, 0xc5, 0x6b,
+	0x78, 0xc5, 0x9e, 0x8c, 0xb0, 0xf3, 0x9c, 0x1e, 0x10, 0x97, 0x2f, 0x7e, 0x60, 0xba, 0x0c, 0x7d,
+	0x17, 0xb2, 0xe6, 0x70, 0xe0, 0xb8, 0x16, 0x7b, 0x36, 0x92, 0x17, 0x6f, 0xba, 0x34, 0xf3, 0x14,
+	0x32, 0x8d, 0x2d, 0x5f, 0x13, 0x87, 0x83, 0xd0, 0xbb, 0x80, 0x26, 0x94, 0x18, 0xc2, 0x38, 0xb1,
+	0xe8, 0xb4, 0x29, 0x6f, 0xe1, 0x4a, 0x13, 0x4a, 0xc2, 0x69, 0x0e, 0x9b, 0xfa, 0xdf, 0x34, 0x40,
+	0xd1, 0x79, 0x65, 0x8e, 0xfe, 0x26, 0xa4, 0xf8, 0x78, 0x5a, 0x55, 0x78, 0x6c, 0xd7, 0x82, 0x0c,
+	0x75, 0x4a, 0xb7, 0xe1, 0x99, 0x8d, 0xa5, 0x7a, 0xed, 0x53, 0xc8, 0xfb, 0x3b, 0x95, 0xbb, 0x13,
+	0x8d, 0x86, 0x72, 0xe1, 0xe9, 0xaa, 0xce, 0x71, 0xba, 0xd6, 0x3e, 0x82, 0x2c, 0xaf, 0xea, 0x2e,
+	0x9d, 0x3b, 0xac, 0x45, 0xd5, 0x68, 0x2d, 0x5a, 0xfb, 0x97, 0x02, 0x09, 0x3e, 0x78, 0xee, 0x97,
+	0xdf, 0x5d, 0xfe, 0xbe, 0x20, 0xac, 0x14, 0xd1, 0x13, 0x49, 0xfb, 0xde, 0x05, 0x90, 0x44, 0x21,
+	0xc0, 0xf9, 0xe3, 0x28, 0x20, 0x2d, 0x00, 0xf1, 0x71, 0x03, 0x9f, 0x4a, 0xf0, 0xf0, 0xab, 0x17,
+	0x4c, 0x15, 0xb8, 0x8b, 0xb3, 0x34, 0xf0, 0x1c, 0x41, 0x82, 0x5a, 0x3f, 0x13, 0x59, 0x52, 0xc3,
+	0xfc, 0x59, 0x7f, 0x1f, 0x6e, 0x3f, 0x22, 0xac, 0xe3, 0x4e, 0xfd, 0xed, 0xe6, 0x6f, 0x9f, 0x0b,
+	0x60, 0xd2, 0x31, 0xdc, 0x89, 0x0f, 0x92, 0x0c, 0xf8, 0x16, 0xe4, 0xa9, 0x3b, 0x35, 0x66, 0x46,
+	0x7a, 0x55, 0x49, 0x10, 0x9e, 0xe8, 0xa0, 0x1c, 0x0d, 0x1b, 0xfa, 0xdf, 0x15, 0x28, 0x1e, 0x5e,
+	0xe7, 0xe8, 0x88, 0x95, 0x50, 0xea, 0x9c, 0x25, 0xd4, 0x3d, 0x48, 0x4e, 0x07, 0x4c, 0xde, 0xea,
+	0x7a, 0x11, 0x8d, 0x7c, 0xb5, 0x72, 0xf8, 0x88, 0x59, 0x7d, 0x2c, 0xe4, 0x5e, 0x61, 0xf4, 0x63,
+	0x6b, 0xc8, 0x88, 0x1b, 0x9c, 0x32, 0x11, 0xcd, 0x8f, 0xb9, 0x04, 0x4b, 0x0d, 0xfd, 0x3b, 0x50,
+	0x0a, 0x7c, 0x09, 0xeb, 0x2a, 0x32, 0x25, 0x76, 0xb0, 0x37, 0x66, 0x86, 0x1f, 0xee, 0x78, 0x22,
+	0x2c, 0x35, 0xf4, 0xdf, 0xa9, 0xb0, 0xf2, 0x64, 0xdc, 0x37, 0xd9, 0xb2, 0x9f, 0xa5, 0x0b, 0x96,
+	0xad, 0xab, 0x90, 0x65, 0xd6, 0x88, 0x50, 0x66, 0x8e, 0xc6, 0x32, 0xab, 0x85, 0x1d, 0x5e, 0x44,
+	0x38, 0x0e, 0xf2, 0x32, 0xd6, 0xdf, 0x63, 0x1c, 0xa2, 0xae, 0x73, 0x4c, 0x6c, 0x2c, 0xe4, 0xfa,
+	0x31, 0x54, 0x66, 0x51, 0x92, 0x50, 0xd7, 0xfd, 0x09, 0x66, 0x2b, 0x58, 0x59, 0xf8, 0x72, 0xa4,
+	0x85, 0x02, 0x7a, 0x07, 0xca, 0x5e, 0x29, 0x3b, 0x22, 0x46, 0x68, 0x8f, 0xf8, 0x5a, 0xa4, 0x24,
+	0xfa, 0xbb, 0x7e, 0xf7, 0xfd, 0x87, 0x50, 0x8a, 0x7d, 0x66, 0x83, 0x4a, 0x90, 0x7b, 0xb2, 0xd7,
+	0x39, 0xd8, 0x69, 0xb5, 0x3f, 0x6e, 0xef, 0x3c, 0x2c, 0xbf, 0x86, 0x00, 0x52, 0x9d, 0xf6, 0xde,
+	0xa3, 0xc7, 0x3b, 0x65, 0x05, 0x65, 0x21, 0xb9, 0xfb, 0xe4, 0x71, 0xb7, 0x5d, 0x56, 0xbd, 0xc7,
+	0xee, 0xd3, 0xfd, 0x83, 0x56, 0x59, 0xbb, 0xff, 0x21, 0xe4, 0x44, 0x5d, 0xb8, 0xef, 0xf6, 0x89,
+	0xeb, 0x0d, 0xd8, 0xdb, 0xc7, 0xbb, 0x5b, 0x8f, 0xcb, 0xaf, 0xa1, 0x34, 0x68, 0x07, 0xd8, 0x1b,
+	0x99, 0x81, 0xc4, 0xc1, 0x7e, 0xa7, 0x5b, 0x56, 0x51, 0x11, 0x60, 0xeb, 0x49, 0x77, 0xbf, 0xb5,
+	0xbf, 0xbb, 0xdb, 0xee, 0x96, 0xb5, 0xed, 0x0f, 0xa0, 0x64, 0x39, 0x8d, 0xa9, 0xc5, 0x08, 0xa5,
+	0xe2, 0x43, 0xa9, 0x1f, 0xbe, 0x2d, 0x5b, 0x96, 0xb3, 0x29, 0x9e, 0x36, 0x07, 0xce, 0xe6, 0x94,
+	0x6d, 0x72, 0xe9, 0xa6, 0x48, 0x10, 0x47, 0x29, 0xde, 0x7a, 0xff, 0xff, 0x01, 0x00, 0x00, 0xff,
+	0xff, 0x4b, 0xc0, 0xed, 0xac, 0xa8, 0x25, 0x00, 0x00,
 }
--- a/vendor/vitess.io/vitess/go/vt/vterrors/vterrors.go
+++ b/vendor/vitess.io/vitess/go/vt/vterrors/vterrors.go
@@ -83,7 +83,7 @@ import (
 var LogErrStacks bool

 func init() {
-	flag.BoolVar(&LogErrStacks, "LogErrStacks", false, "log stack traces in errors")
+	flag.BoolVar(&LogErrStacks, "log_err_stacks", false, "log stack traces for errors")
 }

 // New returns an error with the supplied message.