// ExecuteKeyspaceIds is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) ExecuteKeyspaceIds(ctx context.Context, request *pb.ExecuteKeyspaceIdsRequest) (response *pb.ExecuteKeyspaceIdsResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.CallerId, callerid.NewImmediateCallerID("grpc client")) reply := new(proto.QueryResult) executeErr := vtg.server.ExecuteKeyspaceIds(ctx, string(request.Query.Sql), tproto.Proto3ToBindVariables(request.Query.BindVariables), request.Keyspace, key.ProtoToKeyspaceIds(request.KeyspaceIds), request.TabletType, proto.ProtoToSession(request.Session), request.NotInTransaction, reply) response = &pb.ExecuteKeyspaceIdsResponse{ Error: vtgate.VtGateErrorToVtRPCError(executeErr, reply.Error), } if executeErr == nil { response.Result = mproto.QueryResultToProto3(reply.Result) response.Session = proto.SessionToProto(reply.Session) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, executeErr }
// ExecuteBatchShards is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) ExecuteBatchShards(ctx context.Context, request *pb.ExecuteBatchShardsRequest) (response *pb.ExecuteBatchShardsResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.CallerId, callerid.NewImmediateCallerID("grpc client")) reply := new(proto.QueryResultList) executeErr := vtg.server.ExecuteBatchShards(ctx, proto.ProtoToBoundShardQueries(request.Queries), request.TabletType, request.AsTransaction, proto.ProtoToSession(request.Session), reply) response = &pb.ExecuteBatchShardsResponse{ Error: vtgate.VtGateErrorToVtRPCError(executeErr, reply.Error), } if executeErr == nil { response.Results = tproto.QueryResultListToProto3(reply.List) response.Session = proto.SessionToProto(reply.Session) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, executeErr }
// ExecuteEntityIds is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) ExecuteEntityIds(ctx context.Context, request *pb.ExecuteEntityIdsRequest, response *pb.ExecuteEntityIdsResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("bsonp3 client")) reply := new(proto.QueryResult) executeErr := vtg.server.ExecuteEntityIds(ctx, string(request.Query.Sql), tproto.Proto3ToBindVariables(request.Query.BindVariables), request.Keyspace, request.EntityColumnName, request.EntityKeyspaceIds, request.TabletType, proto.ProtoToSession(request.Session), request.NotInTransaction, reply) if executeErr == nil { response.Error = vtgate.RPCErrorToVtRPCError(reply.Err) response.Result = mproto.QueryResultToProto3(reply.Result) response.Session = proto.SessionToProto(reply.Session) } return vterrors.ToJSONError(executeErr) }
// ExecuteKeyspaceIds is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) ExecuteKeyspaceIds(ctx context.Context, request *pb.ExecuteKeyspaceIdsRequest, response *pb.ExecuteKeyspaceIdsResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("gorpc client")) reply := &proto.QueryResult{} vtgErr := vtg.server.ExecuteKeyspaceIds(ctx, string(request.Query.Sql), tproto.Proto3ToBindVariables(request.Query.BindVariables), request.Keyspace, request.KeyspaceIds, request.TabletType, proto.ProtoToSession(request.Session), request.NotInTransaction, reply) response.Error = vtgate.VtGateErrorToVtRPCError(vtgErr, reply.Error) response.Result = mproto.QueryResultToProto3(reply.Result) response.Session = proto.SessionToProto(reply.Session) if *vtgate.RPCErrorOnlyInReply { return nil } return vtgErr }
// ExecuteKeyspaceIds is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) ExecuteKeyspaceIds(ctx context.Context, request *pb.ExecuteKeyspaceIdsRequest) (response *pb.ExecuteKeyspaceIdsResponse, err error) { defer vtg.server.HandlePanic(&err) query := &proto.KeyspaceIdQuery{ Sql: string(request.Query.Sql), BindVariables: tproto.Proto3ToBindVariables(request.Query.BindVariables), Keyspace: request.Keyspace, KeyspaceIds: key.ProtoToKeyspaceIds(request.KeyspaceIds), TabletType: topo.ProtoToTabletType(request.TabletType), Session: proto.ProtoToSession(request.Session), NotInTransaction: request.NotInTransaction, } reply := new(proto.QueryResult) executeErr := vtg.server.ExecuteKeyspaceIds(ctx, query, reply) response = &pb.ExecuteKeyspaceIdsResponse{ Error: vtgate.VtGateErrorToVtRPCError(executeErr, reply.Error), } if executeErr == nil { response.Result = mproto.QueryResultToProto3(reply.Result) response.Session = proto.SessionToProto(reply.Session) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, executeErr }
// Begin is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) Begin(ctx context.Context, request *pb.BeginRequest, response *pb.BeginResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() session := &proto.Session{} err = vtg.server.Begin(ctx, session) response.Session = proto.SessionToProto(session) return }
// Begin is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) Begin(ctx context.Context, request *pb.BeginRequest) (response *pb.BeginResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.CallerId, callerid.NewImmediateCallerID("grpc client")) outSession := new(proto.Session) vtgErr := vtg.server.Begin(ctx, outSession) response = &pb.BeginResponse{} if vtgErr == nil { response.Session = proto.SessionToProto(outSession) return response, nil } return nil, vterrors.ToGRPCError(vtgErr) }
// Begin is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) Begin(ctx context.Context, request *pb.BeginRequest, response *pb.BeginResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("bsonp3 client")) outSession := new(proto.Session) vtgErr := vtg.server.Begin(ctx, outSession) if vtgErr == nil { response.Session = proto.SessionToProto(outSession) return nil } return vterrors.ToJSONError(vtgErr) }
// Begin is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) Begin(ctx context.Context, request *pb.BeginRequest) (response *pb.BeginResponse, err error) { defer vtg.server.HandlePanic(&err) outSession := new(proto.Session) beginErr := vtg.server.Begin(ctx, outSession) response = &pb.BeginResponse{ Error: vtgate.VtGateErrorToVtRPCError(beginErr, ""), } if beginErr == nil { response.Session = proto.SessionToProto(outSession) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, beginErr }
// Begin2 is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) Begin2(ctx context.Context, request *pb.BeginRequest, response *pb.BeginResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("gorpc client")) // Don't pass in a nil pointer session := &proto.Session{} vtgErr := vtg.server.Begin(ctx, session) response.Session = proto.SessionToProto(session) response.Error = vtgate.VtGateErrorToVtRPCError(vtgErr, "") if *vtgate.RPCErrorOnlyInReply { return nil } return vtgErr }
// Begin is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) Begin(ctx context.Context, request *pb.BeginRequest) (response *pb.BeginResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.CallerId, callerid.NewImmediateCallerID("grpc client")) outSession := new(proto.Session) beginErr := vtg.server.Begin(ctx, outSession) response = &pb.BeginResponse{ Error: vtgate.VtGateErrorToVtRPCError(beginErr, ""), } if beginErr == nil { response.Session = proto.SessionToProto(outSession) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, beginErr }
// ExecuteBatchKeyspaceIds is the RPC version of // vtgateservice.VTGateService method func (vtg *VTGateP3) ExecuteBatchKeyspaceIds(ctx context.Context, request *pb.ExecuteBatchKeyspaceIdsRequest, response *pb.ExecuteBatchKeyspaceIdsResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("bsonp3 client")) reply := new(proto.QueryResultList) executeErr := vtg.server.ExecuteBatchKeyspaceIds(ctx, proto.ProtoToBoundKeyspaceIdQueries(request.Queries), request.TabletType, request.AsTransaction, proto.ProtoToSession(request.Session), reply) if executeErr == nil { response.Error = vtgate.RPCErrorToVtRPCError(reply.Err) response.Results = tproto.QueryResultListToProto3(reply.List) response.Session = proto.SessionToProto(reply.Session) } return vterrors.ToJSONError(executeErr) }
// ExecuteBatchShards is the RPC version of vtgateservice.VTGateService method func (vtg *VTGateP3) ExecuteBatchShards(ctx context.Context, request *pb.ExecuteBatchShardsRequest, response *pb.ExecuteBatchShardsResponse) (err error) { defer vtg.server.HandlePanic(&err) ctx, cancel := context.WithDeadline(ctx, time.Now().Add(*rpcTimeout)) defer cancel() ctx = callerid.NewContext(ctx, request.CallerId, callerid.NewImmediateCallerID("gorpc client")) reply := &proto.QueryResultList{} vtgErr := vtg.server.ExecuteBatchShards(ctx, proto.ProtoToBoundShardQueries(request.Queries), request.TabletType, request.AsTransaction, proto.ProtoToSession(request.Session), reply) response.Error = vtgate.VtGateErrorToVtRPCError(vtgErr, reply.Error) response.Results = tproto.QueryResultListToProto3(reply.List) response.Session = proto.SessionToProto(reply.Session) if *vtgate.RPCErrorOnlyInReply { return nil } return vtgErr }
// ExecuteBatchKeyspaceIds is the RPC version of // vtgateservice.VTGateService method func (vtg *VTGate) ExecuteBatchKeyspaceIds(ctx context.Context, request *pb.ExecuteBatchKeyspaceIdsRequest) (response *pb.ExecuteBatchKeyspaceIdsResponse, err error) { defer vtg.server.HandlePanic(&err) query := &proto.KeyspaceIdBatchQuery{ Session: proto.ProtoToSession(request.Session), Queries: proto.ProtoToBoundKeyspaceIdQueries(request.Queries), TabletType: topo.ProtoToTabletType(request.TabletType), AsTransaction: request.AsTransaction, } reply := new(proto.QueryResultList) executeErr := vtg.server.ExecuteBatchKeyspaceIds(ctx, query, reply) response = &pb.ExecuteBatchKeyspaceIdsResponse{ Error: vtgate.VtGateErrorToVtRPCError(executeErr, reply.Error), } if executeErr == nil { response.Results = tproto.QueryResultListToProto3(reply.List) response.Session = proto.SessionToProto(reply.Session) return response, nil } if *vtgate.RPCErrorOnlyInReply { return response, nil } return nil, executeErr }