// Proto3ToBindVariables converts a proto.BinVariable map to internal data structure
func Proto3ToBindVariables(bv map[string]*querypb.BindVariable) (map[string]interface{}, error) {
if len(bv) == 0 {
return nil, nil
}
result := make(map[string]interface{})
for k, v := range bv {
if v == nil {
continue
}
if v.Type == sqltypes.Tuple {
list := make([]interface{}, len(v.Values))
for i, lv := range v.Values {
v, err := sqltypes.ValueFromBytes(lv.Type, lv.Value)
if err != nil {
return nil, err
}
// TODO(sougou): Change this to just v.
list[i] = v.ToNative()
}
result[k] = list
} else {
v, err := sqltypes.ValueFromBytes(v.Type, v.Value)
if err != nil {
return nil, err
}
// TODO(sougou): Change this to just v.
result[k] = v.ToNative()
}
}
return result, nil
}
// ProtoToEntityIds converts an array of EntityId from proto3
func ProtoToEntityIds(l []*vtgatepb.ExecuteEntityIdsRequest_EntityId) []EntityId {
if len(l) == 0 {
return nil
}
result := make([]EntityId, len(l))
for i, e := range l {
v, err := sqltypes.ValueFromBytes(e.Type, e.Value)
if err != nil {
panic(err)
}
result[i].KeyspaceID = e.KeyspaceId
result[i].ExternalID = v.ToNative()
}
return result
}
func mapEntityIdsToShards(ctx context.Context, topoServ topo.SrvTopoServer, cell, keyspace string, entityIds []*vtgatepb.ExecuteEntityIdsRequest_EntityId, tabletType topodatapb.TabletType) (string, map[string][]interface{}, error) {
keyspace, _, allShards, err := getKeyspaceShards(ctx, topoServ, cell, keyspace, tabletType)
if err != nil {
return "", nil, err
}
var shards = make(map[string][]interface{})
for _, eid := range entityIds {
shard, err := getShardForKeyspaceID(allShards, eid.KeyspaceId)
if err != nil {
return "", nil, err
}
v, err := sqltypes.ValueFromBytes(eid.Type, eid.Value)
if err != nil {
return "", nil, err
}
shards[shard] = append(shards[shard], v.ToNative())
}
return keyspace, shards, nil
}
// bigRatToValue converts 'number' to an SQL value with SQL type: valueType.
// If valueType is integral it truncates 'number' to the integer part according to the
// semantics of the big.Rat.Int method.
func bigRatToValue(number *big.Rat, valueType querypb.Type) sqltypes.Value {
var numberAsBytes []byte
switch {
case sqltypes.IsIntegral(valueType):
// 'number.Num()' returns a reference to the numerator of 'number'.
// We copy it here to avoid changing 'number'.
truncatedNumber := new(big.Int).Set(number.Num())
truncatedNumber.Quo(truncatedNumber, number.Denom())
numberAsBytes = bigIntToSliceOfBytes(truncatedNumber)
case sqltypes.IsFloat(valueType):
// Truncate to the closest 'float'.
// There's not much we can do if there isn't an exact representation.
numberAsFloat64, _ := number.Float64()
numberAsBytes = strconv.AppendFloat([]byte{}, numberAsFloat64, 'f', -1, 64)
default:
panic(fmt.Sprintf("Unsupported type: %v", valueType))
}
result, err := sqltypes.ValueFromBytes(valueType, numberAsBytes)
if err != nil {
panic(fmt.Sprintf("sqltypes.ValueFromBytes failed with: %v", err))
}
return result
}