Imported the latest https://github.com/youtube/vitess sqlparser

This is based on commit 6cf14dbf97f28eebd37dc2bc36374852946336a8.

Multiple changes were made to isolate the code. Including dropping some functions that weren't needed, making copies of dependencies, and dropping the protobuf support.

There are some instructions in the readme.md on how to do this import in future (with cp/sed/diff commands).

Author: bramp

Makefile

@@ -1,11 +1,21 @@
-# Copyright 2012, Google Inc. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can
-# be found in the LICENSE file.
+# Copyright 2017 Google Inc.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 
 MAKEFLAGS = -s
 
 sql.go: sql.y
-	go tool yacc -o sql.go sql.y
+	goyacc -o sql.go sql.y
 	gofmt -w sql.go
 
 clean:

analyzer.go

@@ -1,8 +1,18 @@
-// Copyright 2012, Google Inc. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
+/*
+Copyright 2017 Google Inc.
 
-//Modified by Wenbin Xiao 2015.04.18
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
 
 package sqlparser
 
@@ -11,87 +21,128 @@ package sqlparser
 import (
 	"errors"
 	"fmt"
+	"strconv"
+	"strings"
+	"unicode"
+
 	"github.com/xwb1989/sqlparser/dependency/sqltypes"
 )
 
-// GetTableName returns the table name from the SimpleTableExpr
-// only if it's a simple expression. Otherwise, it returns "".
-func GetTableName(node SimpleTableExpr) string {
-	if n, ok := node.(*TableName); ok && n.Qualifier == nil {
-		return string(n.Name)
+// These constants are used to identify the SQL statement type.
+const (
+	StmtSelect = iota
+	StmtInsert
+	StmtReplace
+	StmtUpdate
+	StmtDelete
+	StmtDDL
+	StmtBegin
+	StmtCommit
+	StmtRollback
+	StmtSet
+	StmtShow
+	StmtUse
+	StmtOther
+	StmtUnknown
+)
+
+// Preview analyzes the beginning of the query using a simpler and faster
+// textual comparison to identify the statement type.
+func Preview(sql string) int {
+	trimmed := StripLeadingComments(sql)
+
+	firstWord := trimmed
+	if end := strings.IndexFunc(trimmed, unicode.IsSpace); end != -1 {
+		firstWord = trimmed[:end]
 	}
-	// sub-select or '.' expression
-	return ""
-}
 
-// Get the primary key ColumnDefinition of the table, sqlNode must be a CreateTable struct
-func GetPrimaryKey(sqlNode SQLNode) (*ColumnDefinition, error) {
-	node, ok := sqlNode.(*CreateTable)
-	if !ok {
-		return nil, errors.New("fail to convert interface SQLNode to struct CreateTable")
+	// Comparison is done in order of priority.
+	loweredFirstWord := strings.ToLower(firstWord)
+	switch loweredFirstWord {
+	case "select":
+		return StmtSelect
+	case "insert":
+		return StmtInsert
+	case "replace":
+		return StmtReplace
+	case "update":
+		return StmtUpdate
+	case "delete":
+		return StmtDelete
 	}
-	for _, col := range node.ColumnDefinitions {
-		for _, att := range col.ColumnAtts {
-			if att == AST_PRIMARY_KEY {
-				return col, nil
-			}
-		}
+	switch strings.ToLower(trimmed) {
+	case "begin", "start transaction":
+		return StmtBegin
+	case "commit":
+		return StmtCommit
+	case "rollback":
+		return StmtRollback
 	}
-	return nil, errors.New("unable to find primary key")
+	switch loweredFirstWord {
+	case "create", "alter", "rename", "drop":
+		return StmtDDL
+	case "set":
+		return StmtSet
+	case "show":
+		return StmtShow
+	case "use":
+		return StmtUse
+	case "analyze", "describe", "desc", "explain", "repair", "optimize", "truncate":
+		return StmtOther
+	}
+	return StmtUnknown
 }
 
-//Get ColumnDefinition by name, sqlNode must be a CreateTable struct
-func GetColumnByName(sqlNode SQLNode, name string) (*ColumnDefinition, error) {
-	node, ok := sqlNode.(*CreateTable)
-	if !ok {
-		return nil, errors.New("fail to convert interface SQLNode to struct CreateTable")
-	}
-	for _, col := range node.ColumnDefinitions {
-		if col.ColName == name {
-			return col, nil
-		}
+// IsDML returns true if the query is an INSERT, UPDATE or DELETE statement.
+func IsDML(sql string) bool {
+	switch Preview(sql) {
+	case StmtInsert, StmtReplace, StmtUpdate, StmtDelete:
+		return true
 	}
-	return nil, errors.New("unable to find the column")
+	return false
 }
 
-// GetColName returns the column name, only if
-// it's a simple expression. Otherwise, it returns "".
-func GetColName(node Expr) string {
-	if n, ok := node.(*ColName); ok {
-		return string(n.Name)
+// GetTableName returns the table name from the SimpleTableExpr
+// only if it's a simple expression. Otherwise, it returns "".
+func GetTableName(node SimpleTableExpr) TableIdent {
+	if n, ok := node.(TableName); ok && n.Qualifier.IsEmpty() {
+		return n.Name
 	}
-	return ""
+	// sub-select or '.' expression
+	return NewTableIdent("")
 }
 
-// IsColName returns true if the ValExpr is a *ColName.
-func IsColName(node ValExpr) bool {
+// IsColName returns true if the Expr is a *ColName.
+func IsColName(node Expr) bool {
 	_, ok := node.(*ColName)
 	return ok
 }
 
-// IsValue returns true if the ValExpr is a string, number or value arg.
+// IsValue returns true if the Expr is a string, integral or value arg.
 // NULL is not considered to be a value.
-func IsValue(node ValExpr) bool {
-	switch node.(type) {
-	case StrVal, NumVal, ValArg:
-		return true
+func IsValue(node Expr) bool {
+	switch v := node.(type) {
+	case *SQLVal:
+		switch v.Type {
+		case StrVal, HexVal, IntVal, ValArg:
+			return true
+		}
 	}
 	return false
 }
 
-// HasINCaluse returns true if any of the conditions has an IN clause.
-func HasINClause(conditions []BoolExpr) bool {
-	for _, node := range conditions {
-		if c, ok := node.(*ComparisonExpr); ok && c.Operator == AST_IN {
-			return true
-		}
+// IsNull returns true if the Expr is SQL NULL
+func IsNull(node Expr) bool {
+	switch node.(type) {
+	case *NullVal:
+		return true
 	}
 	return false
 }
 
-// IsSimpleTuple returns true if the ValExpr is a ValTuple that
+// IsSimpleTuple returns true if the Expr is a ValTuple that
 // contains simple values or if it's a list arg.
-func IsSimpleTuple(node ValExpr) bool {
+func IsSimpleTuple(node Expr) bool {
 	switch vals := node.(type) {
 	case ValTuple:
 		for _, n := range vals {
@@ -107,38 +158,49 @@ func IsSimpleTuple(node ValExpr) bool {
 	return false
 }
 
-// AsInterface converts the ValExpr to an interface. It converts
-// ValTuple to []interface{}, ValArg to string, StrVal to sqltypes.String,
-// NumVal to sqltypes.Numeric, NullVal to nil.
-// Otherwise, it returns an error.
-func AsInterface(node ValExpr) (interface{}, error) {
+// NewPlanValue builds a sqltypes.PlanValue from an Expr.
+func NewPlanValue(node Expr) (sqltypes.PlanValue, error) {
 	switch node := node.(type) {
-	case ValTuple:
-		vals := make([]interface{}, 0, len(node))
-		for _, val := range node {
-			v, err := AsInterface(val)
+	case *SQLVal:
+		switch node.Type {
+		case ValArg:
+			return sqltypes.PlanValue{Key: string(node.Val[1:])}, nil
+		case IntVal:
+			n, err := sqltypes.NewIntegral(string(node.Val))
 			if err != nil {
-				return nil, err
+				return sqltypes.PlanValue{}, fmt.Errorf("%v", err)
 			}
-			vals = append(vals, v)
+			return sqltypes.PlanValue{Value: n}, nil
+		case StrVal:
+			return sqltypes.PlanValue{Value: sqltypes.MakeTrusted(sqltypes.VarBinary, node.Val)}, nil
+		case HexVal:
+			v, err := node.HexDecode()
+			if err != nil {
+				return sqltypes.PlanValue{}, fmt.Errorf("%v", err)
+			}
+			return sqltypes.PlanValue{Value: sqltypes.MakeTrusted(sqltypes.VarBinary, v)}, nil
 		}
-		return vals, nil
-	case ValArg:
-		return string(node), nil
 	case ListArg:
-		return string(node), nil
-	case StrVal:
-		return sqltypes.MakeString(node), nil
-	case NumVal:
-		n, err := sqltypes.BuildNumeric(string(node))
-		if err != nil {
-			return nil, fmt.Errorf("type mismatch: %s", err)
+		return sqltypes.PlanValue{ListKey: string(node[2:])}, nil
+	case ValTuple:
+		pv := sqltypes.PlanValue{
+			Values: make([]sqltypes.PlanValue, 0, len(node)),
 		}
-		return n, nil
+		for _, val := range node {
+			innerpv, err := NewPlanValue(val)
+			if err != nil {
+				return sqltypes.PlanValue{}, err
+			}
+			if innerpv.ListKey != "" || innerpv.Values != nil {
+				return sqltypes.PlanValue{}, errors.New("unsupported: nested lists")
+			}
+			pv.Values = append(pv.Values, innerpv)
+		}
+		return pv, nil
 	case *NullVal:
-		return nil, nil
+		return sqltypes.PlanValue{}, nil
 	}
-	return nil, fmt.Errorf("unexpected node %v", node)
+	return sqltypes.PlanValue{}, fmt.Errorf("expression is too complex '%v'", String(node))
 }
 
 // StringIn is a convenience function that returns
@@ -151,3 +213,48 @@ func StringIn(str string, values ...string) bool {
 	}
 	return false
 }
+
+// ExtractSetValues returns a map of key-value pairs
+// if the query is a SET statement. Values can be int64 or string.
+// Since set variable names are case insensitive, all keys are returned
+// as lower case.
+func ExtractSetValues(sql string) (keyValues map[string]interface{}, charset string, err error) {
+	stmt, err := Parse(sql)
+	if err != nil {
+		return nil, "", err
+	}
+	setStmt, ok := stmt.(*Set)
+	if !ok {
+		return nil, "", fmt.Errorf("ast did not yield *sqlparser.Set: %T", stmt)
+	}
+	result := make(map[string]interface{})
+	for _, expr := range setStmt.Exprs {
+		if !expr.Name.Qualifier.IsEmpty() {
+			return nil, "", fmt.Errorf("invalid syntax: %v", String(expr.Name))
+		}
+		key := expr.Name.Name.Lowered()
+
+		switch expr := expr.Expr.(type) {
+		case *SQLVal:
+			switch expr.Type {
+			case StrVal:
+				result[key] = string(expr.Val)
+			case IntVal:
+				num, err := strconv.ParseInt(string(expr.Val), 0, 64)
+				if err != nil {
+					return nil, "", err
+				}
+				result[key] = num
+			default:
+				return nil, "", fmt.Errorf("invalid value type: %v", String(expr))
+			}
+		case *NullVal:
+			result[key] = nil
+		case *Default:
+			result[key] = "default"
+		default:
+			return nil, "", fmt.Errorf("invalid syntax: %s", String(expr))
+		}
+	}
+	return result, setStmt.Charset.Lowered(), nil
+}