gitlab-com-seaweedfs/seaweedfs
1
0
Fork 0
mirror of https://github.com/seaweedfs/seaweedfs.git synced 2024-01-19 02:48:24 +00:00
Code Issues Projects Releases Wiki Activity

add some basic sql types

Browse source 
copied some code from vitness
This commit is contained in:
Chris Lu 2019-10-02 12:06:31 -07:00
parent cf47f657af
commit e26670c67a
4 changed files with 613 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

124
weed/query/sqltypes/const.go Normal file
View file

@ -0,0 +1,124 @@
package sqltypes
// copied from vitness
// Flag allows us to qualify types by their common properties.
type Flag int32
const (
Flag_NONE Flag = 0
Flag_ISINTEGRAL Flag = 256
Flag_ISUNSIGNED Flag = 512
Flag_ISFLOAT Flag = 1024
Flag_ISQUOTED Flag = 2048
Flag_ISTEXT Flag = 4096
Flag_ISBINARY Flag = 8192
)
var Flag_name = map[int32]string{
0: "NONE",
256: "ISINTEGRAL",
512: "ISUNSIGNED",
1024: "ISFLOAT",
2048: "ISQUOTED",
4096: "ISTEXT",
8192: "ISBINARY",
}
var Flag_value = map[string]int32{
"NONE": 0,
"ISINTEGRAL": 256,
"ISUNSIGNED": 512,
"ISFLOAT": 1024,
"ISQUOTED": 2048,
"ISTEXT": 4096,
"ISBINARY": 8192,
}
// Type defines the various supported data types in bind vars
// and query results.
type Type int32
const (
// NULL_TYPE specifies a NULL type.
Type_NULL_TYPE Type = 0
// INT8 specifies a TINYINT type.
// Properties: 1, IsNumber.
Type_INT8 Type = 257
// UINT8 specifies a TINYINT UNSIGNED type.
// Properties: 2, IsNumber, IsUnsigned.
Type_UINT8 Type = 770
// INT16 specifies a SMALLINT type.
// Properties: 3, IsNumber.
Type_INT16 Type = 259
// UINT16 specifies a SMALLINT UNSIGNED type.
// Properties: 4, IsNumber, IsUnsigned.
Type_UINT16 Type = 772
// INT24 specifies a MEDIUMINT type.
// Properties: 5, IsNumber.
Type_INT32 Type = 263
// UINT32 specifies a INTEGER UNSIGNED type.
// Properties: 8, IsNumber, IsUnsigned.
Type_UINT32 Type = 776
// INT64 specifies a BIGINT type.
// Properties: 9, IsNumber.
Type_INT64 Type = 265
// UINT64 specifies a BIGINT UNSIGNED type.
// Properties: 10, IsNumber, IsUnsigned.
Type_UINT64 Type = 778
// FLOAT32 specifies a FLOAT type.
// Properties: 11, IsFloat.
Type_FLOAT32 Type = 1035
// FLOAT64 specifies a DOUBLE or REAL type.
// Properties: 12, IsFloat.
Type_FLOAT64 Type = 1036
// TIMESTAMP specifies a TIMESTAMP type.
// Properties: 13, IsQuoted.
Type_TIMESTAMP Type = 2061
// DATE specifies a DATE type.
// Properties: 14, IsQuoted.
Type_DATE Type = 2062
// TIME specifies a TIME type.
// Properties: 15, IsQuoted.
Type_TIME Type = 2063
// DATETIME specifies a DATETIME type.
// Properties: 16, IsQuoted.
Type_DATETIME Type = 2064
// YEAR specifies a YEAR type.
// Properties: 17, IsNumber, IsUnsigned.
Type_YEAR Type = 785
// DECIMAL specifies a DECIMAL or NUMERIC type.
// Properties: 18, None.
Type_DECIMAL Type = 18
// TEXT specifies a TEXT type.
// Properties: 19, IsQuoted, IsText.
Type_TEXT Type = 6163
// BLOB specifies a BLOB type.
// Properties: 20, IsQuoted, IsBinary.
Type_BLOB Type = 10260
// VARCHAR specifies a VARCHAR type.
// Properties: 21, IsQuoted, IsText.
Type_VARCHAR Type = 6165
// VARBINARY specifies a VARBINARY type.
// Properties: 22, IsQuoted, IsBinary.
Type_VARBINARY Type = 10262
// CHAR specifies a CHAR type.
// Properties: 23, IsQuoted, IsText.
Type_CHAR Type = 6167
// BINARY specifies a BINARY type.
// Properties: 24, IsQuoted, IsBinary.
Type_BINARY Type = 10264
// BIT specifies a BIT type.
// Properties: 25, IsQuoted.
Type_BIT Type = 2073
// JSON specifies a JSON type.
// Properties: 30, IsQuoted.
Type_JSON Type = 2078
)
// BindVariable represents a single bind variable in a Query.
type BindVariable struct {
Type Type `protobuf:"varint,1,opt,name=type,enum=query.Type" json:"type,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
// values are set if type is TUPLE.
Values []*Value `protobuf:"bytes,3,rep,name=values" json:"values,omitempty"`
}

102
weed/query/sqltypes/type.go Normal file
View file

@ -0,0 +1,102 @@
package sqltypes
// These bit flags can be used to query on the
// common properties of types.
const (
flagIsIntegral = int(Flag_ISINTEGRAL)
flagIsUnsigned = int(Flag_ISUNSIGNED)
flagIsFloat = int(Flag_ISFLOAT)
flagIsQuoted = int(Flag_ISQUOTED)
flagIsText = int(Flag_ISTEXT)
flagIsBinary = int(Flag_ISBINARY)
)
// IsIntegral returns true if Type is an integral
// (signed/unsigned) that can be represented using
// up to 64 binary bits.
// If you have a Value object, use its member function.
func IsIntegral(t Type) bool {
return int(t)&flagIsIntegral == flagIsIntegral
}
// IsSigned returns true if Type is a signed integral.
// If you have a Value object, use its member function.
func IsSigned(t Type) bool {
return int(t)&(flagIsIntegral|flagIsUnsigned) == flagIsIntegral
}
// IsUnsigned returns true if Type is an unsigned integral.
// Caution: this is not the same as !IsSigned.
// If you have a Value object, use its member function.
func IsUnsigned(t Type) bool {
return int(t)&(flagIsIntegral|flagIsUnsigned) == flagIsIntegral|flagIsUnsigned
}
// IsFloat returns true is Type is a floating point.
// If you have a Value object, use its member function.
func IsFloat(t Type) bool {
return int(t)&flagIsFloat == flagIsFloat
}
// IsQuoted returns true if Type is a quoted text or binary.
// If you have a Value object, use its member function.
func IsQuoted(t Type) bool {
return (int(t)&flagIsQuoted == flagIsQuoted) && t != Bit
}
// IsText returns true if Type is a text.
// If you have a Value object, use its member function.
func IsText(t Type) bool {
return int(t)&flagIsText == flagIsText
}
// IsBinary returns true if Type is a binary.
// If you have a Value object, use its member function.
func IsBinary(t Type) bool {
return int(t)&flagIsBinary == flagIsBinary
}
// isNumber returns true if the type is any type of number.
func isNumber(t Type) bool {
return IsIntegral(t) || IsFloat(t) || t == Decimal
}
// IsTemporal returns true if Value is time type.
func IsTemporal(t Type) bool {
switch t {
case Timestamp, Date, Time, Datetime:
return true
}
return false
}
// Vitess data types. These are idiomatically
// named synonyms for the Type values.
const (
Null = Type_NULL_TYPE
Int8 = Type_INT8
Uint8 = Type_UINT8
Int16 = Type_INT16
Uint16 = Type_UINT16
Int32 = Type_INT32
Uint32 = Type_UINT32
Int64 = Type_INT64
Uint64 = Type_UINT64
Float32 = Type_FLOAT32
Float64 = Type_FLOAT64
Timestamp = Type_TIMESTAMP
Date = Type_DATE
Time = Type_TIME
Datetime = Type_DATETIME
Year = Type_YEAR
Decimal = Type_DECIMAL
Text = Type_TEXT
Blob = Type_BLOB
VarChar = Type_VARCHAR
VarBinary = Type_VARBINARY
Char = Type_CHAR
Binary = Type_BINARY
Bit = Type_BIT
TypeJSON = Type_JSON
)

30
weed/query/sqltypes/unsafe.go Normal file
View file

@ -0,0 +1,30 @@
package sqltypes
import (
"reflect"
"unsafe"
)
// BytesToString casts slice to string without copy
func BytesToString(b []byte) (s string) {
if len(b) == 0 {
return ""
}
bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
sh := reflect.StringHeader{Data: bh.Data, Len: bh.Len}
return *(*string)(unsafe.Pointer(&sh))
}
// StringToBytes casts string to slice without copy
func StringToBytes(s string) []byte {
if len(s) == 0 {
return []byte{}
}
sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
bh := reflect.SliceHeader{Data: sh.Data, Len: sh.Len, Cap: sh.Len}
return *(*[]byte)(unsafe.Pointer(&bh))
}

357
weed/query/sqltypes/value.go Normal file
View file

@ -0,0 +1,357 @@
package sqltypes
import (
"fmt"
"strconv"
"time"
)
var (
// NULL represents the NULL value.
NULL = Value{}
// DontEscape tells you if a character should not be escaped.
DontEscape = byte(255)
nullstr = []byte("null")
)
type Value struct {
typ Type
val []byte
}
// NewValue builds a Value using typ and val. If the value and typ
// don't match, it returns an error.
func NewValue(typ Type, val []byte) (v Value, err error) {
switch {
case IsSigned(typ):
if _, err := strconv.ParseInt(string(val), 0, 64); err != nil {
return NULL, err
}
return MakeTrusted(typ, val), nil
case IsUnsigned(typ):
if _, err := strconv.ParseUint(string(val), 0, 64); err != nil {
return NULL, err
}
return MakeTrusted(typ, val), nil
case IsFloat(typ) || typ == Decimal:
if _, err := strconv.ParseFloat(string(val), 64); err != nil {
return NULL, err
}
return MakeTrusted(typ, val), nil
case IsQuoted(typ) || typ == Bit || typ == Null:
return MakeTrusted(typ, val), nil
}
// All other types are unsafe or invalid.
return NULL, fmt.Errorf("invalid type specified for MakeValue: %v", typ)
}
// MakeTrusted makes a new Value based on the type.
// This function should only be used if you know the value
// and type conform to the rules. Every place this function is
// called, a comment is needed that explains why it's justified.
// Exceptions: The current package and mysql package do not need
// comments. Other packages can also use the function to create
// VarBinary or VarChar values.
func MakeTrusted(typ Type, val []byte) Value {
if typ == Null {
return NULL
}
return Value{typ: typ, val: val}
}
// NewInt64 builds an Int64 Value.
func NewInt64(v int64) Value {
return MakeTrusted(Int64, strconv.AppendInt(nil, v, 10))
}
// NewInt32 builds an Int64 Value.
func NewInt32(v int32) Value {
return MakeTrusted(Int32, strconv.AppendInt(nil, int64(v), 10))
}
// NewUint64 builds an Uint64 Value.
func NewUint64(v uint64) Value {
return MakeTrusted(Uint64, strconv.AppendUint(nil, v, 10))
}
// NewFloat32 builds an Float64 Value.
func NewFloat32(v float32) Value {
return MakeTrusted(Float32, strconv.AppendFloat(nil, float64(v), 'f', -1, 64))
}
// NewFloat64 builds an Float64 Value.
func NewFloat64(v float64) Value {
return MakeTrusted(Float64, strconv.AppendFloat(nil, v, 'g', -1, 64))
}
// NewVarChar builds a VarChar Value.
func NewVarChar(v string) Value {
return MakeTrusted(VarChar, []byte(v))
}
// NewVarBinary builds a VarBinary Value.
// The input is a string because it's the most common use case.
func NewVarBinary(v string) Value {
return MakeTrusted(VarBinary, []byte(v))
}
// NewIntegral builds an integral type from a string representation.
// The type will be Int64 or Uint64. Int64 will be preferred where possible.
func NewIntegral(val string) (n Value, err error) {
signed, err := strconv.ParseInt(val, 0, 64)
if err == nil {
return MakeTrusted(Int64, strconv.AppendInt(nil, signed, 10)), nil
}
unsigned, err := strconv.ParseUint(val, 0, 64)
if err != nil {
return Value{}, err
}
return MakeTrusted(Uint64, strconv.AppendUint(nil, unsigned, 10)), nil
}
// MakeString makes a VarBinary Value.
func MakeString(val []byte) Value {
return MakeTrusted(VarBinary, val)
}
// BuildValue builds a value from any go type. sqltype.Value is
// also allowed.
func BuildValue(goval interface{}) (v Value, err error) {
// Look for the most common types first.
switch goval := goval.(type) {
case nil:
// no op
case []byte:
v = MakeTrusted(VarBinary, goval)
case int64:
v = MakeTrusted(Int64, strconv.AppendInt(nil, int64(goval), 10))
case uint64:
v = MakeTrusted(Uint64, strconv.AppendUint(nil, uint64(goval), 10))
case float64:
v = MakeTrusted(Float64, strconv.AppendFloat(nil, goval, 'f', -1, 64))
case int:
v = MakeTrusted(Int64, strconv.AppendInt(nil, int64(goval), 10))
case int8:
v = MakeTrusted(Int8, strconv.AppendInt(nil, int64(goval), 10))
case int16:
v = MakeTrusted(Int16, strconv.AppendInt(nil, int64(goval), 10))
case int32:
v = MakeTrusted(Int32, strconv.AppendInt(nil, int64(goval), 10))
case uint:
v = MakeTrusted(Uint64, strconv.AppendUint(nil, uint64(goval), 10))
case uint8:
v = MakeTrusted(Uint8, strconv.AppendUint(nil, uint64(goval), 10))
case uint16:
v = MakeTrusted(Uint16, strconv.AppendUint(nil, uint64(goval), 10))
case uint32:
v = MakeTrusted(Uint32, strconv.AppendUint(nil, uint64(goval), 10))
case float32:
v = MakeTrusted(Float32, strconv.AppendFloat(nil, float64(goval), 'f', -1, 64))
case string:
v = MakeTrusted(VarBinary, []byte(goval))
case time.Time:
v = MakeTrusted(Datetime, []byte(goval.Format("2006-01-02 15:04:05")))
case Value:
v = goval
case *BindVariable:
return ValueFromBytes(goval.Type, goval.Value)
default:
return v, fmt.Errorf("unexpected type %T: %v", goval, goval)
}
return v, nil
}
// BuildConverted is like BuildValue except that it tries to
// convert a string or []byte to an integral if the target type
// is an integral. We don't perform other implicit conversions
// because they're unsafe.
func BuildConverted(typ Type, goval interface{}) (v Value, err error) {
if IsIntegral(typ) {
switch goval := goval.(type) {
case []byte:
return ValueFromBytes(typ, goval)
case string:
return ValueFromBytes(typ, []byte(goval))
case Value:
if goval.IsQuoted() {
return ValueFromBytes(typ, goval.Raw())
}
}
}
return BuildValue(goval)
}
// ValueFromBytes builds a Value using typ and val. It ensures that val
// matches the requested type. If type is an integral it's converted to
// a canonical form. Otherwise, the original representation is preserved.
func ValueFromBytes(typ Type, val []byte) (v Value, err error) {
switch {
case IsSigned(typ):
signed, err := strconv.ParseInt(string(val), 0, 64)
if err != nil {
return NULL, err
}
v = MakeTrusted(typ, strconv.AppendInt(nil, signed, 10))
case IsUnsigned(typ):
unsigned, err := strconv.ParseUint(string(val), 0, 64)
if err != nil {
return NULL, err
}
v = MakeTrusted(typ, strconv.AppendUint(nil, unsigned, 10))
case IsFloat(typ) || typ == Decimal:
_, err := strconv.ParseFloat(string(val), 64)
if err != nil {
return NULL, err
}
// After verification, we preserve the original representation.
fallthrough
default:
v = MakeTrusted(typ, val)
}
return v, nil
}
// BuildIntegral builds an integral type from a string representation.
// The type will be Int64 or Uint64. Int64 will be preferred where possible.
func BuildIntegral(val string) (n Value, err error) {
signed, err := strconv.ParseInt(val, 0, 64)
if err == nil {
return MakeTrusted(Int64, strconv.AppendInt(nil, signed, 10)), nil
}
unsigned, err := strconv.ParseUint(val, 0, 64)
if err != nil {
return Value{}, err
}
return MakeTrusted(Uint64, strconv.AppendUint(nil, unsigned, 10)), nil
}
// Type returns the type of Value.
func (v Value) Type() Type {
return v.typ
}
// Raw returns the raw bytes. All types are currently implemented as []byte.
// You should avoid using this function. If you do, you should treat the
// bytes as read-only.
func (v Value) Raw() []byte {
return v.val
}
// Len returns the length.
func (v Value) Len() int {
return len(v.val)
}
// Values represents the array of Value.
type Values []Value
// Len implements the interface.
func (vs Values) Len() int {
len := 0
for _, v := range vs {
len += v.Len()
}
return len
}
// String returns the raw value as a string.
func (v Value) String() string {
return BytesToString(v.val)
}
// ToNative converts Value to a native go type.
// This does not work for sqltypes.Tuple. The function
// panics if there are inconsistencies.
func (v Value) ToNative() interface{} {
var out interface{}
var err error
switch {
case v.typ == Null:
// no-op
case IsSigned(v.typ):
out, err = v.ParseInt64()
case IsUnsigned(v.typ):
out, err = v.ParseUint64()
case IsFloat(v.typ):
out, err = v.ParseFloat64()
default:
out = v.val
}
if err != nil {
panic(err)
}
return out
}
// ParseInt64 will parse a Value into an int64. It does
// not check the type.
func (v Value) ParseInt64() (val int64, err error) {
return strconv.ParseInt(v.String(), 10, 64)
}
// ParseUint64 will parse a Value into a uint64. It does
// not check the type.
func (v Value) ParseUint64() (val uint64, err error) {
return strconv.ParseUint(v.String(), 10, 64)
}
// ParseFloat64 will parse a Value into an float64. It does
// not check the type.
func (v Value) ParseFloat64() (val float64, err error) {
return strconv.ParseFloat(v.String(), 64)
}
// IsNull returns true if Value is null.
func (v Value) IsNull() bool {
return v.typ == Null
}
// IsIntegral returns true if Value is an integral.
func (v Value) IsIntegral() bool {
return IsIntegral(v.typ)
}
// IsSigned returns true if Value is a signed integral.
func (v Value) IsSigned() bool {
return IsSigned(v.typ)
}
// IsUnsigned returns true if Value is an unsigned integral.
func (v Value) IsUnsigned() bool {
return IsUnsigned(v.typ)
}
// IsFloat returns true if Value is a float.
func (v Value) IsFloat() bool {
return IsFloat(v.typ)
}
// IsQuoted returns true if Value must be SQL-quoted.
func (v Value) IsQuoted() bool {
return IsQuoted(v.typ)
}
// IsText returns true if Value is a collatable text.
func (v Value) IsText() bool {
return IsText(v.typ)
}
// IsBinary returns true if Value is binary.
func (v Value) IsBinary() bool {
return IsBinary(v.typ)
}
// IsTemporal returns true if Value is time type.
func (v Value) IsTemporal() bool {
return IsTemporal(v.typ)
}
// ToString returns the value as MySQL would return it as string.
// If the value is not convertible like in the case of Expression, it returns nil.
func (v Value) ToString() string {
return BytesToString(v.val)
}