func (c *Conn) newEmptyResultset(stmt *sqlparser.Select) *Resultset { r := new(Resultset) r.Fields = make([]*Field, len(stmt.SelectExprs)) for i, expr := range stmt.SelectExprs { r.Fields[i] = &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([]RowData, 0) return r }
//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 *Conn) buildSimpleShowResultset(values []interface{}, name string) (*Resultset, error) { r := new(Resultset) field := &Field{} field.Name = hack.Slice(name) field.Charset = 33 field.Type = MYSQL_TYPE_VAR_STRING r.Fields = []*Field{field} var row []byte var err error for _, value := range values { row, err = formatValue(value) if err != nil { return nil, err } r.RowDatas = append(r.RowDatas, PutLengthEncodedString(row)) } return r, nil }
func formatValue(value interface{}) ([]byte, error) { 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)) }
func (c *Conn) buildResultset(names []string, values [][]interface{}) (*Resultset, error) { r := new(Resultset) r.Fields = make([]*Field, len(names)) 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 { field := &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, PutLengthEncodedString(b)...) } r.RowDatas = append(r.RowDatas, row) } return r, nil }