func (c *ClientConn) newEmptyResultset(stmt *sqlparser.Select) *mysql.Resultset {
r := new(mysql.Resultset)
r.Fields = make([]*mysql.Field, len(stmt.SelectExprs))
for i, expr := range stmt.SelectExprs {
r.Fields[i] = &mysql.Field{}
switch e := expr.(type) {
case *sqlparser.StarExpr:
r.Fields[i].Name = []byte("*")
case *sqlparser.NonStarExpr:
if e.As != nil {
r.Fields[i].Name = e.As
r.Fields[i].OrgName = hack.Slice(nstring(e.Expr))
} else {
r.Fields[i].Name = hack.Slice(nstring(e.Expr))
}
default:
r.Fields[i].Name = hack.Slice(nstring(e))
}
}
r.Values = make([][]interface{}, 0)
r.RowDatas = make([]mysql.RowData, 0)
return r
}
func TestCalcPassword(t *testing.T) {
/*
// **** JDBC ****
seed:
@jx=d_3z42;sS$YrS)p|
hex:
406a783d645f337a34323b73532459725329707c
pass:
kingshard
scramble:
fbc71db5ac3d7b51048d1a1d88c1677f34bcca11
*/
test, _ := RandomBuf(20)
hex_test := hex.EncodeToString(test)
t.Logf("rnd seed: %s, %s", hack.String(test), hex_test)
seed := hack.Slice("@jx=d_3z42;sS$YrS)p|")
hex_seed := hex.EncodeToString(seed)
t.Logf("seed: %s equal %s, pass: %v", "406a783d645f337a34323b73532459725329707c", hex_seed, "406a783d645f337a34323b73532459725329707c" == hex_seed)
scramble := CalcPassword(seed, hack.Slice("kingshard"))
hex_scramble := hex.EncodeToString(scramble)
t.Logf("scramble: %s equal %s, pass: %v", "fbc71db5ac3d7b51048d1a1d88c1677f34bcca11", hex_scramble, "fbc71db5ac3d7b51048d1a1d88c1677f34bcca11" == hex_scramble)
}
//compare value using asc
func cmpValue(v1 interface{}, v2 interface{}) int {
if v1 == nil && v2 == nil {
return 0
} else if v1 == nil {
return -1
} else if v2 == nil {
return 1
}
switch v := v1.(type) {
case string:
s := v2.(string)
return bytes.Compare(hack.Slice(v), hack.Slice(s))
case []byte:
s := v2.([]byte)
return bytes.Compare(v, s)
case int64:
s := v2.(int64)
if v < s {
return -1
} else if v > s {
return 1
} else {
return 0
}
case uint64:
s := v2.(uint64)
if v < s {
return -1
} else if v > s {
return 1
} else {
return 0
}
case float64:
s := v2.(float64)
if v < s {
return -1
} else if v > s {
return 1
} else {
return 0
}
default:
//can not go here
panic(fmt.Sprintf("invalid type %T", v))
}
}
func (c *ClientConn) buildResultset(fields []*mysql.Field, names []string, values [][]interface{}) (*mysql.Resultset, error) {
var ExistFields bool
r := new(mysql.Resultset)
r.Fields = make([]*mysql.Field, len(names))
//use the field def that get from true database
if len(fields) != 0 {
if len(r.Fields) == len(fields) {
ExistFields = true
} else {
return nil, errors.ErrInvalidArgument
}
}
var b []byte
var err error
for i, vs := range values {
if len(vs) != len(r.Fields) {
return nil, fmt.Errorf("row %d has %d column not equal %d", i, len(vs), len(r.Fields))
}
var row []byte
for j, value := range vs {
//列的定义
if i == 0 {
if ExistFields {
r.Fields[j] = fields[j]
} else {
field := &mysql.Field{}
r.Fields[j] = field
field.Name = hack.Slice(names[j])
if err = formatField(field, value); err != nil {
return nil, err
}
}
}
b, err = formatValue(value)
if err != nil {
return nil, err
}
row = append(row, mysql.PutLengthEncodedString(b)...)
}
r.RowDatas = append(r.RowDatas, row)
}
return r, nil
}
func formatValue(value interface{}) ([]byte, error) {
if value == nil {
return hack.Slice("NULL"), nil
}
switch v := value.(type) {
case int8:
return strconv.AppendInt(nil, int64(v), 10), nil
case int16:
return strconv.AppendInt(nil, int64(v), 10), nil
case int32:
return strconv.AppendInt(nil, int64(v), 10), nil
case int64:
return strconv.AppendInt(nil, int64(v), 10), nil
case int:
return strconv.AppendInt(nil, int64(v), 10), nil
case uint8:
return strconv.AppendUint(nil, uint64(v), 10), nil
case uint16:
return strconv.AppendUint(nil, uint64(v), 10), nil
case uint32:
return strconv.AppendUint(nil, uint64(v), 10), nil
case uint64:
return strconv.AppendUint(nil, uint64(v), 10), nil
case uint:
return strconv.AppendUint(nil, uint64(v), 10), nil
case float32:
return strconv.AppendFloat(nil, float64(v), 'f', -1, 64), nil
case float64:
return strconv.AppendFloat(nil, float64(v), 'f', -1, 64), nil
case []byte:
return v, nil
case string:
return hack.Slice(v), nil
default:
return nil, fmt.Errorf("invalid type %T", value)
}
}
func HashValue(value interface{}) uint64 {
switch val := value.(type) {
case int:
return uint64(val)
case uint64:
return uint64(val)
case int64:
return uint64(val)
case string:
return uint64(crc32.ChecksumIEEE(hack.Slice(val)))
case []byte:
return uint64(crc32.ChecksumIEEE(val))
}
panic(NewKeyError("Unexpected key variable type %T", value))
}