func TestVTGateStreamExecuteShards(t *testing.T) {
s := createSandbox("TestVTGateStreamExecuteShards")
sbc := &sandboxConn{}
s.MapTestConn("0", sbc)
// Test for successful execution
var qrs []*proto.QueryResult
err := rpcVTGate.StreamExecuteShards(context.Background(),
"query",
nil,
"TestVTGateStreamExecuteShards",
[]string{"0"},
topodatapb.TabletType_MASTER,
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)
}
}
// Execute executes a non-streaming query by routing based on the values in the query.
func (vtg *VTGate) Execute(ctx context.Context, sql string, bindVariables map[string]interface{}, tabletType pb.TabletType, session *proto.Session, notInTransaction bool, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"Execute", "Any", strings.ToLower(tabletType.String())}
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.router.Execute(ctx, sql, bindVariables, tabletType, session, notInTransaction)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
query := map[string]interface{}{
"Sql": sql,
"BindVariables": bindVariables,
"TabletType": strings.ToLower(tabletType.String()),
"Session": session,
"NotInTransaction": notInTransaction,
}
reply.Error = handleExecuteError(err, statsKey, query, vtg.logExecute)
}
reply.Session = session
return nil
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(context interface{}, query *proto.EntityIdsQuery, reply *proto.QueryResult) error {
shardMap, err := mapEntityIdsToShards(
vtg.scatterConn.toposerv,
vtg.scatterConn.cell,
query.Keyspace,
query.EntityKeyspaceIdMap,
query.TabletType)
if err != nil {
return err
}
shards, sqls, bindVars := buildEntityIds(shardMap, query.Sql, query.EntityColumnName, query.BindVariables)
qr, err := vtg.scatterConn.ExecuteEntityIds(
context,
shards,
sqls,
bindVars,
query.Keyspace,
query.TabletType,
NewSafeSession(query.Session))
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
log.Errorf("ExecuteEntityIds: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// StreamExecuteKeyRanges executes a streaming query on the specified KeyRanges.
// The KeyRanges are resolved to shards using the serving graph.
// This function currently temporarily enforces the restriction of executing on
// one shard since it cannot merge-sort the results to guarantee ordering of
// response which is needed for checkpointing.
// The api supports supplying multiple keyranges to make it future proof.
func (vtg *VTGate) StreamExecuteKeyRanges(ctx context.Context, query *proto.KeyRangeQuery, sendReply func(*proto.QueryResult) error) error {
startTime := time.Now()
statsKey := []string{"StreamExecuteKeyRanges", 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.StreamExecuteKeyRanges(
ctx,
query,
func(mreply *mproto.QueryResult) error {
reply := new(proto.QueryResult)
reply.Result = mreply
rowCount += int64(len(mreply.Rows))
vtg.rowsReturned.Add(statsKey, int64(len(mreply.Rows)))
// Note we don't populate reply.Session here,
// as it may change incrementaly as responses are sent.
return sendReply(reply)
})
if err != nil {
normalErrors.Add(statsKey, 1)
logError(err, query, vtg.logStreamExecuteKeyRanges)
}
// Now we can send the final Sessoin info.
if query.Session != nil {
sendReply(&proto.QueryResult{Session: query.Session})
}
return formatError(err)
}
// ExecuteKeyRanges executes a non-streaming query based on the specified keyranges.
func (vtg *VTGate) ExecuteKeyRanges(context interface{}, query *proto.KeyRangeQuery, reply *proto.QueryResult) error {
shards, err := mapKeyRangesToShards(
vtg.scatterConn.toposerv,
vtg.scatterConn.cell,
query.Keyspace,
query.TabletType,
query.KeyRanges)
if err != nil {
return err
}
qr, err := vtg.scatterConn.Execute(
context,
query.Sql,
query.BindVariables,
query.Keyspace,
shards,
query.TabletType,
NewSafeSession(query.Session))
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
log.Errorf("ExecuteKeyRange: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// ExecuteKeyRanges executes a non-streaming query based on the specified keyranges.
func (vtg *VTGate) ExecuteKeyRanges(ctx context.Context, sql string, bindVariables map[string]interface{}, keyspace string, keyRanges []*pb.KeyRange, tabletType pb.TabletType, session *proto.Session, notInTransaction bool, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteKeyRanges", keyspace, strings.ToLower(tabletType.String())}
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
}
sql = sqlannotation.AddFilteredReplicationUnfriendlyIfDML(sql)
qr, err := vtg.resolver.ExecuteKeyRanges(ctx, sql, bindVariables, keyspace, keyRanges, tabletType, session, notInTransaction)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
query := map[string]interface{}{
"Sql": sql,
"BindVariables": bindVariables,
"Keyspace": keyspace,
"KeyRanges": keyRanges,
"TabletType": strings.ToLower(tabletType.String()),
"Session": session,
"NotInTransaction": notInTransaction,
}
reply.Error = handleExecuteError(err, statsKey, query, vtg.logExecuteKeyRanges).Error()
reply.Err = vterrors.RPCErrFromVtError(err)
}
reply.Session = session
return nil
}
// ExecuteShard executes a non-streaming query on the specified shards.
func (vtg *VTGate) ExecuteShard(ctx context.Context, query *proto.QueryShard, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteShard", 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.Execute(
ctx,
query.Sql,
query.BindVariables,
query.Keyspace,
query.TabletType,
query.Session,
func(keyspace string) (string, []string, error) {
return query.Keyspace, query.Shards, nil
},
query.NotInTransaction,
)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
reply.Error = handleExecuteError(err, statsKey, query, vtg.logExecuteShard)
}
reply.Session = query.Session
return nil
}
// StreamExecuteKeyRanges executes a streaming query on the specified KeyRanges.
// The KeyRanges are resolved to shards using the serving graph.
// This function currently temporarily enforces the restriction of executing on
// one shard since it cannot merge-sort the results to guarantee ordering of
// response which is needed for checkpointing.
// The api supports supplying multiple keyranges to make it future proof.
func (vtg *VTGate) StreamExecuteKeyRanges(context context.Context, query *proto.KeyRangeQuery, sendReply func(*proto.QueryResult) error) (err error) {
defer handlePanic(&err)
startTime := time.Now()
statsKey := []string{"StreamExecuteKeyRanges", 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
}
err = vtg.resolver.StreamExecuteKeyRanges(
context,
query,
func(mreply *mproto.QueryResult) error {
reply := new(proto.QueryResult)
reply.Result = mreply
// Note we don't populate reply.Session here,
// as it may change incrementaly as responses are sent.
return sendReply(reply)
})
if err != nil {
normalErrors.Add(statsKey, 1)
vtg.logStreamExecuteKeyRanges.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
}
// ExecuteShard executes a non-streaming query on the specified shards.
func (vtg *VTGate) ExecuteShard(context context.Context, query *proto.QueryShard, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteShard", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
qr, err := vtg.resolver.Execute(
context,
query.Sql,
query.BindVariables,
query.Keyspace,
query.TabletType,
query.Session,
func(keyspace string) (string, []string, error) {
return query.Keyspace, query.Shards, nil
},
)
if err == nil {
reply.Result = qr
} else {
reply.Error = err.Error()
if strings.Contains(reply.Error, errDupKey) {
vtg.infoErrors.Add("DupKey", 1)
} else {
vtg.errors.Add(statsKey, 1)
vtg.logExecuteShard.Errorf("%v, query: %+v", err, query)
}
}
reply.Session = query.Session
return nil
}
// 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
} 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
}
// StreamExecuteShard executes a streaming query on the specified shards.
func (vtg *VTGate) StreamExecuteShard(context context.Context, query *proto.QueryShard, sendReply func(*proto.QueryResult) error) error {
startTime := time.Now()
statsKey := []string{"StreamExecuteShard", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
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
// Note we don't populate reply.Session here,
// as it may change incrementaly as responses are sent.
return sendReply(reply)
})
if err != nil {
vtg.errors.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
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(ctx context.Context, sql string, bindVariables map[string]interface{}, keyspace string, entityColumnName string, entityKeyspaceIDs []*pbg.ExecuteEntityIdsRequest_EntityId, tabletType pb.TabletType, session *proto.Session, notInTransaction bool, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteEntityIds", keyspace, strings.ToLower(tabletType.String())}
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(ctx, sql, bindVariables, keyspace, entityColumnName, entityKeyspaceIDs, tabletType, session, notInTransaction)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
query := map[string]interface{}{
"Sql": sql,
"BindVariables": bindVariables,
"Keyspace": keyspace,
"EntityColumnName": entityColumnName,
"EntityKeyspaceIDs": entityKeyspaceIDs,
"TabletType": strings.ToLower(tabletType.String()),
"Session": session,
"NotInTransaction": notInTransaction,
}
reply.Error = handleExecuteError(err, statsKey, query, vtg.logExecuteEntityIds).Error()
reply.Err = rpcErrFromVtGateError(err)
}
reply.Session = 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"},
TabletType: topo.TYPE_REPLICA,
}
qr := new(proto.QueryResult)
err := rpcVTGate.ExecuteShard(context.Background(), &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.Background(), q.Session)
if !q.Session.InTransaction {
t.Errorf("want true, got false")
}
rpcVTGate.ExecuteShard(context.Background(), &q, qr)
wantSession := &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: "TestVTGateExecuteShard",
Shard: "0",
TabletType: topo.TYPE_REPLICA,
TransactionId: 1,
}},
}
if !reflect.DeepEqual(wantSession, q.Session) {
t.Errorf("want \n%+v, got \n%+v", wantSession, q.Session)
}
rpcVTGate.Commit(context.Background(), q.Session)
if commitCount := sbc.CommitCount.Get(); commitCount != 1 {
t.Errorf("want 1, got %d", commitCount)
}
q.Session = new(proto.Session)
rpcVTGate.Begin(context.Background(), q.Session)
rpcVTGate.ExecuteShard(context.Background(), &q, qr)
rpcVTGate.Rollback(context.Background(), q.Session)
/*
// Flaky: This test should be run manually.
runtime.Gosched()
if sbc.RollbackCount != 1 {
t.Errorf("want 1, got %d", sbc.RollbackCount)
}
*/
}
// ExecuteShard executes a non-streaming query on the specified shards.
func (vtg *VTGate) ExecuteShard(context interface{}, query *proto.QueryShard, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteShard", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
qr, err := vtg.resolver.Execute(
context,
query.Sql,
query.BindVariables,
query.Keyspace,
query.TabletType,
query.Session,
func(keyspace string) (string, []string, error) {
return query.Keyspace, query.Shards, nil
},
)
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
vtg.errors.Add(statsKey, 1)
// FIXME(alainjobart): throttle this log entry
log.Errorf("ExecuteShard: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(context interface{}, query *proto.EntityIdsQuery, reply *proto.QueryResult) error {
qr, err := vtg.resolver.ExecuteEntityIds(context, query)
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
log.Errorf("ExecuteEntityIds: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
func (c *errorClient) Execute(ctx context.Context, sql string, bindVariables map[string]interface{}, tabletType pb.TabletType, session *proto.Session, notInTransaction bool, reply *proto.QueryResult) error {
if rpcErr := requestToPartialError(sql); rpcErr != nil {
reply.Err = rpcErr
reply.Error = rpcErr.Message
return nil
}
if err := requestToError(sql); err != nil {
return err
}
return c.fallbackClient.Execute(ctx, sql, bindVariables, tabletType, session, notInTransaction, reply)
}
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)
}
}
func TestVTGateExecute(t *testing.T) {
sandbox := createSandbox(KsTestUnsharded)
sbc := &sandboxConn{}
sandbox.MapTestConn("0", sbc)
q := proto.Query{
Sql: "select * from t1",
TabletType: topo.TYPE_MASTER,
}
qr := new(proto.QueryResult)
err := rpcVTGate.Execute(context.Background(), &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.Background(), q.Session)
if !q.Session.InTransaction {
t.Errorf("want true, got false")
}
rpcVTGate.Execute(context.Background(), &q, qr)
wantSession := &proto.Session{
InTransaction: true,
ShardSessions: []*proto.ShardSession{{
Keyspace: KsTestUnsharded,
Shard: "0",
TabletType: topo.TYPE_MASTER,
TransactionId: 1,
}},
}
if !reflect.DeepEqual(wantSession, q.Session) {
t.Errorf("want \n%+v, got \n%+v", wantSession, q.Session)
}
rpcVTGate.Commit(context.Background(), q.Session)
if sbc.CommitCount != 1 {
t.Errorf("want 1, got %d", sbc.CommitCount)
}
q.Session = new(proto.Session)
rpcVTGate.Begin(context.Background(), q.Session)
rpcVTGate.Execute(context.Background(), &q, qr)
rpcVTGate.Rollback(context.Background(), q.Session)
}
// requestToPartialError fills reply for a partial error if requested.
// It returns true if a partial error was requested, false otherwise.
// This partial error should only be returned by Execute* calls.
func requestToPartialError(request string, session *vtgatepb.Session, reply *proto.QueryResult) bool {
if !strings.HasPrefix(request, PartialErrorPrefix) {
return false
}
request = strings.TrimPrefix(request, PartialErrorPrefix)
parts := strings.Split(request, "/")
rpcErr := vterrors.RPCErrFromVtError(trimmedRequestToError(parts[0]))
reply.Err = rpcErr
reply.Session = session
if len(parts) > 1 && parts[1] == "close transaction" {
reply.Session.InTransaction = false
}
return true
}
func (c *echoClient) Execute(ctx context.Context, sql string, bindVariables map[string]interface{}, tabletType pb.TabletType, session *proto.Session, notInTransaction bool, reply *proto.QueryResult) error {
if strings.HasPrefix(sql, EchoPrefix) {
reply.Result = echoQueryResult(map[string]interface{}{
"callerId": callerid.EffectiveCallerIDFromContext(ctx),
"query": sql,
"bindVars": bindVariables,
"tabletType": tabletType,
"session": session,
"notInTransaction": notInTransaction,
})
reply.Session = session
return nil
}
return c.fallbackClient.Execute(ctx, sql, bindVariables, tabletType, session, notInTransaction, reply)
}
// ExecuteKeyspaceIds executes a non-streaming query based on the specified keyspace ids.
func (vtg *VTGate) ExecuteKeyspaceIds(context interface{}, query *proto.KeyspaceIdQuery, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteKeyspaceIds", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
qr, err := vtg.resolver.ExecuteKeyspaceIds(context, query)
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
vtg.errors.Add(statsKey, 1)
vtg.logExecuteKeyspaceIds.Errorf("%v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(context interface{}, query *proto.EntityIdsQuery, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteEntityIds", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
qr, err := vtg.resolver.ExecuteEntityIds(context, query)
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
vtg.errors.Add(statsKey, 1)
// FIXME(alainjobart): throttle this log entry
log.Errorf("ExecuteEntityIds: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// ExecuteShard executes a non-streaming query on the specified shards.
func (vtg *VTGate) ExecuteShard(context *rpcproto.Context, query *proto.QueryShard, reply *proto.QueryResult) error {
qr, err := vtg.scatterConn.Execute(
query.Sql,
query.BindVariables,
query.Keyspace,
query.Shards,
query.TabletType,
NewSafeSession(query.Session))
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
log.Errorf("ExecuteShard: %v, query: %#v", err, query)
}
reply.Session = query.Session
return nil
}
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")
// Test for successful execution
var qrs []*proto.QueryResult
err = rpcVTGate.StreamExecuteKeyRanges(context.Background(),
"query",
nil,
"TestVTGateStreamExecuteKeyRanges",
[]key.KeyRange{kr},
pb.TabletType_MASTER,
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 shards
kr, err = key.ParseKeyRangeParts("10", "40")
err = rpcVTGate.StreamExecuteKeyRanges(context.Background(),
"query",
nil,
"TestVTGateStreamExecuteKeyRanges",
[]key.KeyRange{kr},
pb.TabletType_MASTER,
func(r *proto.QueryResult) error {
qrs = append(qrs, r)
return nil
})
if err != nil {
t.Errorf("want nil, got %v", err)
}
}
func (c *echoClient) ExecuteEntityIds(ctx context.Context, sql string, bindVariables map[string]interface{}, keyspace string, entityColumnName string, entityKeyspaceIDs []*pbg.ExecuteEntityIdsRequest_EntityId, tabletType pb.TabletType, session *pbg.Session, notInTransaction bool, reply *proto.QueryResult) error {
if strings.HasPrefix(sql, EchoPrefix) {
reply.Result = echoQueryResult(map[string]interface{}{
"callerId": callerid.EffectiveCallerIDFromContext(ctx),
"query": sql,
"bindVars": bindVariables,
"keyspace": keyspace,
"entityColumnName": entityColumnName,
"entityIds": entityKeyspaceIDs,
"tabletType": tabletType,
"session": session,
"notInTransaction": notInTransaction,
})
reply.Session = session
return nil
}
return c.fallbackClient.ExecuteEntityIds(ctx, sql, bindVariables, keyspace, entityColumnName, entityKeyspaceIDs, tabletType, session, notInTransaction, reply)
}
// StreamExecuteShards executes a streaming query on the specified shards.
func (vtg *VTGate) StreamExecuteShards(ctx context.Context, sql string, bindVariables map[string]interface{}, keyspace string, shards []string, tabletType pb.TabletType, sendReply func(*proto.QueryResult) error) error {
startTime := time.Now()
statsKey := []string{"StreamExecuteShards", keyspace, strings.ToLower(tabletType.String())}
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(
ctx,
sql,
bindVariables,
keyspace,
tabletType,
func(keyspace string) (string, []string, error) {
return keyspace, shards, nil
},
func(mreply *mproto.QueryResult) error {
reply := new(proto.QueryResult)
reply.Result = mreply
rowCount += int64(len(mreply.Rows))
vtg.rowsReturned.Add(statsKey, int64(len(mreply.Rows)))
// Note we don't populate reply.Session here,
// as it may change incrementaly as responses are sent.
return sendReply(reply)
})
if err != nil {
normalErrors.Add(statsKey, 1)
query := map[string]interface{}{
"Sql": sql,
"BindVariables": bindVariables,
"Keyspace": keyspace,
"Shards": shards,
"TabletType": strings.ToLower(tabletType.String()),
}
logError(err, query, vtg.logStreamExecuteShards)
}
return formatError(err)
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(context context.Context, query *proto.EntityIdsQuery, reply *proto.QueryResult) error {
startTime := time.Now()
statsKey := []string{"ExecuteEntityIds", query.Keyspace, string(query.TabletType)}
defer vtg.timings.Record(statsKey, startTime)
qr, err := vtg.resolver.ExecuteEntityIds(context, query)
if err == nil {
reply.Result = qr
} else {
reply.Error = err.Error()
if strings.Contains(reply.Error, errDupKey) {
vtg.infoErrors.Add("DupKey", 1)
} else {
vtg.errors.Add(statsKey, 1)
vtg.logExecuteEntityIds.Errorf("%v, query: %+v", err, query)
}
}
reply.Session = query.Session
return nil
}
// ExecuteShard executes a non-streaming query on the specified shards.
func (vtg *VTGate) ExecuteShard(context interface{}, query *proto.QueryShard, reply *proto.QueryResult) error {
qr, err := vtg.resolver.Execute(
context,
query.Sql,
query.BindVariables,
query.Keyspace,
query.TabletType,
query.Session,
func(keyspace string) ([]string, error) {
return query.Shards, nil
},
)
if err == nil {
proto.PopulateQueryResult(qr, reply)
} else {
reply.Error = err.Error()
log.Errorf("ExecuteShard: %v, query: %+v", err, query)
}
reply.Session = query.Session
return nil
}
// ExecuteEntityIds excutes a non-streaming query based on given KeyspaceId map.
func (vtg *VTGate) ExecuteEntityIds(ctx context.Context, query *proto.EntityIdsQuery, reply *proto.QueryResult) error {
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(ctx, query)
if err == nil {
reply.Result = qr
vtg.rowsReturned.Add(statsKey, int64(len(qr.Rows)))
} else {
reply.Error = handleExecuteError(err, statsKey, query, vtg.logExecuteEntityIds)
}
reply.Session = query.Session
return nil
}
func TestVTGateStreamExecute(t *testing.T) {
sandbox := createSandbox(KsTestUnsharded)
sbc := &sandboxConn{}
sandbox.MapTestConn("0", sbc)
var qrs []*proto.QueryResult
err := rpcVTGate.StreamExecute(context.Background(),
"select * from t1",
nil,
topodatapb.TabletType_MASTER,
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)
}
}