*: make parser package dependency as small as possible

ast/ast.go

@@ -19,7 +19,7 @@ import (
 	"io"
 
 	"github.com/pingcap/tidb/model"
-	"github.com/pingcap/tidb/types"
+	"github.com/pingcap/tidb/parser/types"
 )
 
 // Node is the basic element of the AST.

ast/base.go

@@ -13,7 +13,7 @@
 
 package ast
 
-import "github.com/pingcap/tidb/types"
+import "github.com/pingcap/tidb/parser/types"
 
 // node is the struct implements node interface except for Accept method.
 // Node implementations should embed it in.

ast/ddl.go

@@ -15,7 +15,7 @@ package ast
 
 import (
 	"github.com/pingcap/tidb/model"
-	"github.com/pingcap/tidb/types"
+	"github.com/pingcap/tidb/parser/types"
 )
 
 var (

ast/functions.go

@@ -18,7 +18,7 @@ import (
 	"io"
 
 	"github.com/pingcap/tidb/model"
-	"github.com/pingcap/tidb/types"
+	"github.com/pingcap/tidb/parser/types"
 )
 
 var (

ast/misc.go

@@ -868,3 +868,12 @@ func (n *TableOptimizerHint) Accept(v Visitor) (Node, bool) {
 	n = newNode.(*TableOptimizerHint)
 	return v.Leave(n)
 }
+
+// NewDecimal creates a types.Decimal value, it's provided by parser driver.
+var NewDecimal func(string) (interface{}, error)
+
+// NewHexLiteral creates a types.HexLiteral value, it's provided by parser driver.
+var NewHexLiteral func(string) (interface{}, error)
+
+// NewBitLiteral creates a types.BitLiteral value, it's provided by parser driver.
+var NewBitLiteral func(string) (interface{}, error)

model/model.go

@@ -20,8 +20,7 @@ import (
 	"time"
 
 	"github.com/pingcap/tidb/mysql"
-	"github.com/pingcap/tidb/types"
-	"github.com/pingcap/tidb/util/hack"
+	"github.com/pingcap/tidb/parser/types"
 	"github.com/pingcap/tipb/go-tipb"
 	"github.com/pkg/errors"
 )
@@ -114,7 +113,7 @@ func (c *ColumnInfo) SetDefaultValue(value interface{}) error {
 // bit type default value will store in DefaultValueBit for fix bit default value decode/encode bug.
 func (c *ColumnInfo) GetDefaultValue() interface{} {
 	if c.Tp == mysql.TypeBit && c.DefaultValueBit != nil {
-		return hack.String(c.DefaultValueBit)
+		return string(c.DefaultValueBit)
 	}
 	return c.DefaultValue
 }

parser/misc.go

@@ -17,7 +17,6 @@ import (
 	"strings"
 
 	"github.com/pingcap/tidb/util/charset"
-	"github.com/pingcap/tidb/util/hack"
 )
 
 func isLetter(ch rune) bool {
@@ -584,7 +583,7 @@ func (s *Scanner) isTokenIdentifier(lit string, offset int) int {
 		}
 	}
 
-	checkBtFuncToken, tokenStr := false, hack.String(data)
+	checkBtFuncToken, tokenStr := false, string(data)
 	if s.r.peek() == '(' {
 		checkBtFuncToken = true
 	} else if s.sqlMode.HasIgnoreSpaceMode() {

parser/parser.y

@@ -34,7 +34,7 @@ import (
 	"github.com/pingcap/tidb/parser/opcode"
 	"github.com/pingcap/tidb/util/auth"
 	"github.com/pingcap/tidb/util/charset"
-	"github.com/pingcap/tidb/types"
+	"github.com/pingcap/tidb/parser/types"
 )
 
 %}

parser/types/etc.go

@@ -0,0 +1,258 @@
+// Copyright 2014 The ql Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSES/QL-LICENSE file.
+
+// Copyright 2015 PingCAP, 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+import (
+	"strings"
+
+	"github.com/pingcap/tidb/mysql"
+	"github.com/pingcap/tidb/parser/opcode"
+	"github.com/pingcap/tidb/terror"
+	"github.com/pkg/errors"
+)
+
+// IsTypeBlob returns a boolean indicating whether the tp is a blob type.
+func IsTypeBlob(tp byte) bool {
+	switch tp {
+	case mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeBlob, mysql.TypeLongBlob:
+		return true
+	default:
+		return false
+	}
+}
+
+// IsTypeChar returns a boolean indicating
+// whether the tp is the char type like a string type or a varchar type.
+func IsTypeChar(tp byte) bool {
+	return tp == mysql.TypeString || tp == mysql.TypeVarchar
+}
+
+// IsTypeVarchar returns a boolean indicating
+// whether the tp is the varchar type like a varstring type or a varchar type.
+func IsTypeVarchar(tp byte) bool {
+	return tp == mysql.TypeVarString || tp == mysql.TypeVarchar
+}
+
+// IsTypeUnspecified returns a boolean indicating whether the tp is the Unspecified type.
+func IsTypeUnspecified(tp byte) bool {
+	return tp == mysql.TypeUnspecified
+}
+
+// IsTypePrefixable returns a boolean indicating
+// whether an index on a column with the tp can be defined with a prefix.
+func IsTypePrefixable(tp byte) bool {
+	return IsTypeBlob(tp) || IsTypeChar(tp)
+}
+
+// IsTypeFractionable returns a boolean indicating
+// whether the tp can has time fraction.
+func IsTypeFractionable(tp byte) bool {
+	return tp == mysql.TypeDatetime || tp == mysql.TypeDuration || tp == mysql.TypeTimestamp
+}
+
+// IsTypeTime returns a boolean indicating
+// whether the tp is time type like datetime, date or timestamp.
+func IsTypeTime(tp byte) bool {
+	return tp == mysql.TypeDatetime || tp == mysql.TypeDate || tp == mysql.TypeTimestamp
+}
+
+// IsTypeNumeric returns a boolean indicating whether the tp is numeric type.
+func IsTypeNumeric(tp byte) bool {
+	switch tp {
+	case mysql.TypeBit, mysql.TypeTiny, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong, mysql.TypeNewDecimal,
+		mysql.TypeDecimal, mysql.TypeFloat, mysql.TypeDouble, mysql.TypeShort:
+		return true
+	}
+	return false
+}
+
+// IsTemporalWithDate returns a boolean indicating
+// whether the tp is time type with date.
+func IsTemporalWithDate(tp byte) bool {
+	return IsTypeTime(tp)
+}
+
+// IsString returns a boolean indicating
+// whether the field type is a string type.
+func IsString(tp byte) bool {
+	return IsTypeChar(tp) || IsTypeBlob(tp) || IsTypeVarchar(tp) || IsTypeUnspecified(tp)
+}
+
+var type2Str = map[byte]string{
+	mysql.TypeBit:        "bit",
+	mysql.TypeBlob:       "text",
+	mysql.TypeDate:       "date",
+	mysql.TypeDatetime:   "datetime",
+	mysql.TypeDecimal:    "unspecified",
+	mysql.TypeNewDecimal: "decimal",
+	mysql.TypeDouble:     "double",
+	mysql.TypeEnum:       "enum",
+	mysql.TypeFloat:      "float",
+	mysql.TypeGeometry:   "geometry",
+	mysql.TypeInt24:      "mediumint",
+	mysql.TypeJSON:       "json",
+	mysql.TypeLong:       "int",
+	mysql.TypeLonglong:   "bigint",
+	mysql.TypeLongBlob:   "longtext",
+	mysql.TypeMediumBlob: "mediumtext",
+	mysql.TypeNull:       "null",
+	mysql.TypeSet:        "set",
+	mysql.TypeShort:      "smallint",
+	mysql.TypeString:     "char",
+	mysql.TypeDuration:   "time",
+	mysql.TypeTimestamp:  "timestamp",
+	mysql.TypeTiny:       "tinyint",
+	mysql.TypeTinyBlob:   "tinytext",
+	mysql.TypeVarchar:    "varchar",
+	mysql.TypeVarString:  "var_string",
+	mysql.TypeYear:       "year",
+}
+
+var kind2Str = map[byte]string{
+	KindNull:          "null",
+	KindInt64:         "bigint",
+	KindUint64:        "unsigned bigint",
+	KindFloat32:       "float",
+	KindFloat64:       "double",
+	KindString:        "char",
+	KindBytes:         "bytes",
+	KindBinaryLiteral: "bit/hex literal",
+	KindMysqlDecimal:  "decimal",
+	KindMysqlDuration: "time",
+	KindMysqlEnum:     "enum",
+	KindMysqlBit:      "bit",
+	KindMysqlSet:      "set",
+	KindMysqlTime:     "datetime",
+	KindInterface:     "interface",
+	KindMinNotNull:    "min_not_null",
+	KindMaxValue:      "max_value",
+	KindRaw:           "raw",
+	KindMysqlJSON:     "json",
+}
+
+// TypeStr converts tp to a string.
+func TypeStr(tp byte) (r string) {
+	return type2Str[tp]
+}
+
+// KindStr converts kind to a string.
+func KindStr(kind byte) (r string) {
+	return kind2Str[kind]
+}
+
+// TypeToStr converts a field to a string.
+// It is used for converting Text to Blob,
+// or converting Char to Binary.
+// Args:
+//	tp: type enum
+//	cs: charset
+func TypeToStr(tp byte, cs string) (r string) {
+	ts := type2Str[tp]
+	if cs != "binary" {
+		return ts
+	}
+	if IsTypeBlob(tp) {
+		ts = strings.Replace(ts, "text", "blob", 1)
+	} else if IsTypeChar(tp) {
+		ts = strings.Replace(ts, "char", "binary", 1)
+	}
+	return ts
+}
+
+// InvOp2 returns an invalid operation error.
+func InvOp2(x, y interface{}, o opcode.Op) (interface{}, error) {
+	return nil, errors.Errorf("Invalid operation: %v %v %v (mismatched types %T and %T)", x, o, y, x, y)
+}
+
+// IsTypeTemporal checks if a type is a temporal type.
+func IsTypeTemporal(tp byte) bool {
+	switch tp {
+	case mysql.TypeDuration, mysql.TypeDatetime, mysql.TypeTimestamp,
+		mysql.TypeDate, mysql.TypeNewDate:
+		return true
+	}
+	return false
+}
+
+// Kind constants.
+const (
+	KindNull          byte = 0
+	KindInt64         byte = 1
+	KindUint64        byte = 2
+	KindFloat32       byte = 3
+	KindFloat64       byte = 4
+	KindString        byte = 5
+	KindBytes         byte = 6
+	KindBinaryLiteral byte = 7 // Used for BIT / HEX literals.
+	KindMysqlDecimal  byte = 8
+	KindMysqlDuration byte = 9
+	KindMysqlEnum     byte = 10
+	KindMysqlBit      byte = 11 // Used for BIT table column values.
+	KindMysqlSet      byte = 12
+	KindMysqlTime     byte = 13
+	KindInterface     byte = 14
+	KindMinNotNull    byte = 15
+	KindMaxValue      byte = 16
+	KindRaw           byte = 17
+	KindMysqlJSON     byte = 18
+)
+
+var (
+	dig2bytes = [10]int{0, 1, 1, 2, 2, 3, 3, 4, 4, 4}
+)
+
+// RoundMode is the type for round mode.
+type RoundMode string
+
+// constant values.
+const (
+	ten0 = 1
+	ten1 = 10
+	ten2 = 100
+	ten3 = 1000
+	ten4 = 10000
+	ten5 = 100000
+	ten6 = 1000000
+	ten7 = 10000000
+	ten8 = 100000000
+	ten9 = 1000000000
+
+	maxWordBufLen = 9 // A MyDecimal holds 9 words.
+	digitsPerWord = 9 // A word holds 9 digits.
+	wordSize      = 4 // A word is 4 bytes int32.
+	digMask       = ten8
+	wordBase      = ten9
+	wordMax       = wordBase - 1
+	notFixedDec   = 31
+
+	DivFracIncr = 4
+
+	// ModeHalfEven rounds normally.
+	ModeHalfEven RoundMode = "ModeHalfEven"
+	// Truncate just truncates the decimal.
+	ModeTruncate RoundMode = "Truncate"
+	// Ceiling is not supported now.
+	modeCeiling RoundMode = "Ceiling"
+)
+
+const (
+	codeInvalidDefault = terror.ErrCode(mysql.ErrInvalidDefault)
+)
+
+// ErrInvalidDefault is returned when meet a invalid default value.
+var ErrInvalidDefault = terror.ClassTypes.New(codeInvalidDefault, "Invalid default value for '%s'")

parser/types/eval_type.go

@@ -0,0 +1,42 @@
+// Copyright 2017 PingCAP, 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,
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package types
+
+// EvalType indicates the specified types that arguments and result of a built-in function should be.
+type EvalType byte
+
+const (
+	// ETInt represents type INT in evaluation.
+	ETInt EvalType = iota
+	// ETReal represents type REAL in evaluation.
+	ETReal
+	// ETDecimal represents type DECIMAL in evaluation.
+	ETDecimal
+	// ETString represents type STRING in evaluation.
+	ETString
+	// ETDatetime represents type DATETIME in evaluation.
+	ETDatetime
+	// ETTimestamp represents type TIMESTAMP in evaluation.
+	ETTimestamp
+	// ETDuration represents type DURATION in evaluation.
+	ETDuration
+	// ETJson represents type JSON in evaluation.
+	ETJson
+)
+
+// IsStringKind returns true for ETString, ETDatetime, ETTimestamp, ETDuration, ETJson EvalTypes.
+func (et EvalType) IsStringKind() bool {
+	return et == ETString || et == ETDatetime ||
+		et == ETTimestamp || et == ETDuration || et == ETJson
+}