// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(context context.Context, query *proto.EntityIdsQuery, reply *proto.QueryResult) (err error) {
defer handlePanic(&err)
startTime := time.Now()
statsKey := []string{"ExecuteEntityIds", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
x := vtg.inFlight.Add(1)
defer vtg.inFlight.Add(-1)
if 0 < vtg.maxInFlight && vtg.maxInFlight < x {
return ErrTooManyInFlight
}
qr, err := vtg.resolver.ExecuteEntityIds(context, query)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
reply.Error = err.Error()
if strings.Contains(reply.Error, errDupKey) {
infoErrors.Add("DupKey", 1)
} else {
normalErrors.Add(statsKey, 1)
vtg.logExecuteEntityIds.Errorf("%v, query: %+v", err, query)
}
}
reply.Session = query.Session
return nil
}
func TestVTGateExecuteShard(t *testing.T) {
sandbox := createSandbox("TestVTGateExecuteShard")
sbc := &sandboxConn{}
sandbox.MapTestConn("0", sbc)
q := proto.QueryShard{
Sql: "query",
Keyspace: "TestVTGateExecuteShard",
Shards: []string{"0"},
}
qr := new(proto.QueryResult)
err := RpcVTGate.ExecuteShard(&context.DummyContext{}, &q, qr)
if err != nil {
t.Errorf("want nil, got %v", err)
}
wantqr := new(proto.QueryResult)
wantqr.Result = singleRowResult
if !reflect.DeepEqual(wantqr, qr) {
t.Errorf("want \n%+v, got \n%+v", singleRowResult, qr)
}
if qr.Session != nil {
t.Errorf("want nil, got %+v\n", qr.Session)
}
q.Session = new(proto.Session)
RpcVTGate.Begin(&context.DummyContext{}, q.Session)
if !q.Session.InTransaction {
t.Errorf("want true, got false")
}
RpcVTGate.ExecuteShard(&context.DummyContext{}, &q, qr)
wantSession := &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateExecuteShard",
Shard: "0",
TransactionId: 1,
}},
}
if !reflect.DeepEqual(wantSession, q.Session) {
t.Errorf("want \n%+v, got \n%+v", wantSession, q.Session)
}
RpcVTGate.Commit(&context.DummyContext{}, q.Session)
if sbc.CommitCount != 1 {
t.Errorf("want 1, got %d", sbc.CommitCount)
}
q.Session = new(proto.Session)
RpcVTGate.Begin(&context.DummyContext{}, q.Session)
RpcVTGate.ExecuteShard(&context.DummyContext{}, &q, qr)
RpcVTGate.Rollback(&context.DummyContext{}, q.Session)
/*
// Flaky: This test should be run manually.
runtime.Gosched()
if sbc.RollbackCount != 1 {
t.Errorf("want 1, got %d", sbc.RollbackCount)
}
*/
}
func TestVTGateStreamExecuteShard(t *testing.T) {
s := createSandbox("TestVTGateStreamExecuteShard")
sbc := &sandboxConn{}
s.MapTestConn("0", sbc)
q := proto.QueryShard{
Sql: "query",
Keyspace: "TestVTGateStreamExecuteShard",
Shards: []string{"0"},
TabletType: topo.TYPE_MASTER,
}
// Test for successful execution
var qrs []*proto.QueryResult
err := RpcVTGate.StreamExecuteShard(&context.DummyContext{}, &q, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
row := new(proto.QueryResult)
row.Result = singleRowResult
want := []*proto.QueryResult{row}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
q.Session = new(proto.Session)
qrs = nil
RpcVTGate.Begin(&context.DummyContext{}, q.Session)
err = RpcVTGate.StreamExecuteShard(&context.DummyContext{}, &q, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
want = []*proto.QueryResult{
row,
&proto.QueryResult{
Session: &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateStreamExecuteShard",
Shard: "0",
TransactionId: 1,
TabletType: topo.TYPE_MASTER,
}},
},
},
}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
}
// StreamExecuteShard executes a streaming query on the specified shards.
func (vtg *VTGate) StreamExecuteShard(context context.Context, query *proto.QueryShard, sendReply func(*proto.QueryResult) error) (err error) {
defer handlePanic(&err)
startTime := time.Now()
statsKey := []string{"StreamExecuteShard", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
x := vtg.inFlight.Add(1)
defer vtg.inFlight.Add(-1)
if 0 < vtg.maxInFlight && vtg.maxInFlight < x {
return ErrTooManyInFlight
}
var rowCount int64
err = vtg.resolver.StreamExecute(
context,
query.Sql,
query.BindVariables,
query.Keyspace,
query.TabletType,
query.Session,
func(keyspace string) (string, []string, error) {
return query.Keyspace, query.Shards, nil
},
func(mreply *mproto.QueryResult) error {
reply := new(proto.QueryResult)
reply.Result = mreply
rowCount += int64(len(mreply.Rows))
// Note we don't populate reply.Session here,
// as it may change incrementaly as responses are sent.
return sendReply(reply)
})
vtg.rowsReturned.Add(statsKey, rowCount)
if err != nil {
normalErrors.Add(statsKey, 1)
vtg.logStreamExecuteShard.Errorf("%v, query: %+v", err, query)
}
// Now we can send the final Sessoin info.
if query.Session != nil {
sendReply(&proto.QueryResult{Session: query.Session})
}
return err
}
func TestVTGateExecuteKeyspaceIds(t *testing.T) {
s := createSandbox("TestVTGateExecuteKeyspaceIds")
sbc1 := &sandboxConn{}
sbc2 := &sandboxConn{}
s.MapTestConn("-20", sbc1)
s.MapTestConn("20-40", sbc2)
kid10, err := key.HexKeyspaceId("10").Unhex()
if err != nil {
t.Errorf("want nil, got %+v", err)
}
q := proto.KeyspaceIdQuery{
Sql: "query",
Keyspace: "TestVTGateExecuteKeyspaceIds",
KeyspaceIds: []key.KeyspaceId{kid10},
TabletType: topo.TYPE_MASTER,
}
// Test for successful execution
qr := new(proto.QueryResult)
err = RpcVTGate.ExecuteKeyspaceIds(&context.DummyContext{}, &q, qr)
if err != nil {
t.Errorf("want nil, got %v", err)
}
wantqr := new(proto.QueryResult)
wantqr.Result = singleRowResult
if !reflect.DeepEqual(wantqr, qr) {
t.Errorf("want \n%+v, got \n%+v", singleRowResult, qr)
}
if qr.Session != nil {
t.Errorf("want nil, got %+v\n", qr.Session)
}
if sbc1.ExecCount != 1 {
t.Errorf("want 1, got %v\n", sbc1.ExecCount)
}
// Test for successful execution in transaction
q.Session = new(proto.Session)
RpcVTGate.Begin(&context.DummyContext{}, q.Session)
if !q.Session.InTransaction {
t.Errorf("want true, got false")
}
RpcVTGate.ExecuteKeyspaceIds(&context.DummyContext{}, &q, qr)
wantSession := &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateExecuteKeyspaceIds",
Shard: "-20",
TransactionId: 1,
TabletType: topo.TYPE_MASTER,
}},
}
if !reflect.DeepEqual(wantSession, q.Session) {
t.Errorf("want \n%+v, got \n%+v", wantSession, q.Session)
}
RpcVTGate.Commit(&context.DummyContext{}, q.Session)
if sbc1.CommitCount.Get() != 1 {
t.Errorf("want 1, got %d", sbc1.CommitCount.Get())
}
// Test for multiple shards
kid30, err := key.HexKeyspaceId("30").Unhex()
if err != nil {
t.Errorf("want nil, got %+v", err)
}
q.KeyspaceIds = []key.KeyspaceId{kid10, kid30}
RpcVTGate.ExecuteKeyspaceIds(&context.DummyContext{}, &q, qr)
if qr.Result.RowsAffected != 2 {
t.Errorf("want 2, got %v", qr.Result.RowsAffected)
}
}
func TestVTGateStreamExecuteKeyRanges(t *testing.T) {
s := createSandbox("TestVTGateStreamExecuteKeyRanges")
sbc := &sandboxConn{}
s.MapTestConn("-20", sbc)
sbc1 := &sandboxConn{}
s.MapTestConn("20-40", sbc1)
kr, err := key.ParseKeyRangeParts("", "20")
sq := proto.KeyRangeQuery{
Sql: "query",
Keyspace: "TestVTGateStreamExecuteKeyRanges",
KeyRanges: []key.KeyRange{kr},
TabletType: topo.TYPE_MASTER,
}
// Test for successful execution
var qrs []*proto.QueryResult
err = RpcVTGate.StreamExecuteKeyRanges(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
row := new(proto.QueryResult)
row.Result = singleRowResult
want := []*proto.QueryResult{row}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
sq.Session = new(proto.Session)
qrs = nil
RpcVTGate.Begin(&context.DummyContext{}, sq.Session)
err = RpcVTGate.StreamExecuteKeyRanges(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
want = []*proto.QueryResult{
row,
&proto.QueryResult{
Session: &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateStreamExecuteKeyRanges",
Shard: "-20",
TransactionId: 1,
TabletType: topo.TYPE_MASTER,
}},
},
},
}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
// Test for successful execution - multiple shards
kr, err = key.ParseKeyRangeParts("10", "40")
sq.KeyRanges = []key.KeyRange{kr}
err = RpcVTGate.StreamExecuteKeyRanges(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
}
func TestVTGateStreamExecuteKeyspaceIds(t *testing.T) {
s := createSandbox("TestVTGateStreamExecuteKeyspaceIds")
sbc := &sandboxConn{}
s.MapTestConn("-20", sbc)
sbc1 := &sandboxConn{}
s.MapTestConn("20-40", sbc1)
kid10, err := key.HexKeyspaceId("10").Unhex()
if err != nil {
t.Errorf("want nil, got %+v", err)
}
sq := proto.KeyspaceIdQuery{
Sql: "query",
Keyspace: "TestVTGateStreamExecuteKeyspaceIds",
KeyspaceIds: []key.KeyspaceId{kid10},
TabletType: topo.TYPE_MASTER,
}
// Test for successful execution
var qrs []*proto.QueryResult
err = RpcVTGate.StreamExecuteKeyspaceIds(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
row := new(proto.QueryResult)
row.Result = singleRowResult
want := []*proto.QueryResult{row}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
// Test for successful execution in transaction
sq.Session = new(proto.Session)
qrs = nil
RpcVTGate.Begin(&context.DummyContext{}, sq.Session)
err = RpcVTGate.StreamExecuteKeyspaceIds(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
want = []*proto.QueryResult{
row,
&proto.QueryResult{
Session: &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateStreamExecuteKeyspaceIds",
Shard: "-20",
TransactionId: 1,
TabletType: topo.TYPE_MASTER,
}},
},
},
}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want\n%#v\ngot\n%#v", want, qrs)
}
RpcVTGate.Commit(&context.DummyContext{}, sq.Session)
if sbc.CommitCount.Get() != 1 {
t.Errorf("want 1, got %d", sbc.CommitCount.Get())
}
// Test for successful execution - multiple keyspaceids in single shard
sq.Session = nil
qrs = nil
kid15, err := key.HexKeyspaceId("15").Unhex()
if err != nil {
t.Errorf("want nil, got %+v", err)
}
sq.KeyspaceIds = []key.KeyspaceId{kid10, kid15}
err = RpcVTGate.StreamExecuteKeyspaceIds(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
row = new(proto.QueryResult)
row.Result = singleRowResult
want = []*proto.QueryResult{row}
if !reflect.DeepEqual(want, qrs) {
t.Errorf("want \n%+v, got \n%+v", want, qrs)
}
// Test for successful execution - multiple keyspaceids in multiple shards
kid30, err := key.HexKeyspaceId("30").Unhex()
if err != nil {
t.Errorf("want nil, got %+v", err)
}
sq.KeyspaceIds = []key.KeyspaceId{kid10, kid30}
err = RpcVTGate.StreamExecuteKeyspaceIds(&context.DummyContext{}, &sq, func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
}
