func getAllShards(shardSpec string) (key.KeyRangeArray, error) {
shardedKrArray, err := key.ParseShardingSpec(shardSpec)
if err != nil {
return nil, err
}
return shardedKrArray, nil
}
func TestVTGateSplitQuery(t *testing.T) {
keyspace := "TestVTGateSplitQuery"
keyranges, _ := key.ParseShardingSpec(DefaultShardSpec)
s := createSandbox(keyspace)
for _, kr := range keyranges {
s.MapTestConn(fmt.Sprintf("%s-%s", kr.Start, kr.End), &sandboxConn{})
}
sql := "select col1, col2 from table"
splitCount := 24
req := proto.SplitQueryRequest{
Keyspace: keyspace,
Query: tproto.BoundQuery{
Sql: sql,
},
SplitCount: splitCount,
}
result := new(proto.SplitQueryResult)
err := RpcVTGate.SplitQuery(&context.DummyContext{}, &req, result)
if err != nil {
t.Errorf("want nil, got %v", err)
}
_, err = getAllShards(DefaultShardSpec)
// Total number of splits should be number of shards * splitsPerShard
if splitCount != len(result.Splits) {
t.Errorf("wrong number of splits, want \n%+v, got \n%+v", splitCount, len(result.Splits))
}
actualSqlsByKeyRange := map[kproto.KeyRange][]string{}
for _, split := range result.Splits {
if split.Size != sandboxSQRowCount {
t.Errorf("wrong split size, want \n%+v, got \n%+v", sandboxSQRowCount, split.Size)
}
if split.Query.Keyspace != keyspace {
t.Errorf("wrong split size, want \n%+v, got \n%+v", keyspace, split.Query.Keyspace)
}
if len(split.Query.KeyRanges) != 1 {
t.Errorf("wrong number of keyranges, want \n%+v, got \n%+v", 1, len(split.Query.KeyRanges))
}
if split.Query.TabletType != topo.TYPE_RDONLY {
t.Errorf("wrong tablet type, want \n%+v, got \n%+v", topo.TYPE_RDONLY, split.Query.TabletType)
}
kr := split.Query.KeyRanges[0]
actualSqlsByKeyRange[kr] = append(actualSqlsByKeyRange[kr], split.Query.Sql)
}
expectedSqlsByKeyRange := map[kproto.KeyRange][]string{}
for _, kr := range keyranges {
expectedSqlsByKeyRange[kr] = []string{
"select col1, col2 from table /*split 0 */",
"select col1, col2 from table /*split 1 */",
"select col1, col2 from table /*split 2 */",
}
}
if !reflect.DeepEqual(actualSqlsByKeyRange, expectedSqlsByKeyRange) {
t.Errorf("splits contain the wrong sqls and/or keyranges, got: %v, want: %v", actualSqlsByKeyRange, expectedSqlsByKeyRange)
}
}
func TestKeyRangeToShardMap(t *testing.T) {
ts := new(sandboxTopo)
var testCases = []struct {
keyspace string
keyRange string
shards []string
}{
{keyspace: TEST_SHARDED, keyRange: "20-40", shards: []string{"20-40"}},
// check for partial keyrange, spanning one shard
{keyspace: TEST_SHARDED, keyRange: "10-18", shards: []string{"-20"}},
// check for keyrange intersecting with multiple shards
{keyspace: TEST_SHARDED, keyRange: "10-40", shards: []string{"-20", "20-40"}},
// check for keyrange intersecting with multiple shards
{keyspace: TEST_SHARDED, keyRange: "1c-2a", shards: []string{"-20", "20-40"}},
// check for keyrange where kr.End is Max Key ""
{keyspace: TEST_SHARDED, keyRange: "80-", shards: []string{"80-a0", "a0-c0", "c0-e0", "e0-"}},
// test for sharded, non-partial keyrange spanning the entire space.
{keyspace: TEST_SHARDED, keyRange: "", shards: []string{"-20", "20-40", "40-60", "60-80", "80-a0", "a0-c0", "c0-e0", "e0-"}},
// test for unsharded, non-partial keyrange spanning the entire space.
{keyspace: TEST_UNSHARDED, keyRange: "", shards: []string{"0"}},
}
for _, testCase := range testCases {
var keyRange key.KeyRange
var err error
if testCase.keyRange == "" {
keyRange = key.KeyRange{Start: "", End: ""}
} else {
krArray, err := key.ParseShardingSpec(testCase.keyRange)
if err != nil {
t.Errorf("Got error while parsing sharding spec %v", err)
}
keyRange = krArray[0]
}
_, allShards, err := getKeyspaceShards(ts, "", testCase.keyspace, topo.TYPE_MASTER)
gotShards, err := resolveKeyRangeToShards(allShards, keyRange)
if err != nil {
t.Errorf("want nil, got %v", err)
}
if !reflect.DeepEqual(testCase.shards, gotShards) {
t.Errorf("want \n%#v, got \n%#v", testCase.shards, gotShards)
}
}
}
