// 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) bv, err := tproto.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return nil, vterrors.ToGRPCError(err) } executeErr := vtg.server.ExecuteKeyspaceIds(ctx, string(request.Query.Sql), bv, request.Keyspace, request.KeyspaceIds, request.TabletType, request.Session, request.NotInTransaction, reply) response = &pb.ExecuteKeyspaceIdsResponse{ Error: vtgate.RPCErrorToVtRPCError(reply.Err), } if executeErr != nil { return nil, vterrors.ToGRPCError(executeErr) } response.Result = sqltypes.ResultToProto3(reply.Result) response.Session = reply.Session return response, nil }
// BeginExecute is part of the queryservice.QueryServer interface func (q *query) BeginExecute(ctx context.Context, request *querypb.BeginExecuteRequest) (response *querypb.BeginExecuteResponse, err error) { defer q.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.EffectiveCallerId, request.ImmediateCallerId, ) bv, err := querytypes.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return nil, vterrors.ToGRPCError(err) } result, transactionID, err := q.server.BeginExecute(ctx, request.Target, request.Query.Sql, bv, request.Options) if err != nil { // if we have a valid transactionID, return the error in-band if transactionID != 0 { return &querypb.BeginExecuteResponse{ Error: vterrors.VtRPCErrorFromVtError(err), TransactionId: transactionID, }, nil } return nil, vterrors.ToGRPCError(err) } return &querypb.BeginExecuteResponse{ Result: sqltypes.ResultToProto3(result), TransactionId: transactionID, }, nil }
// ExecuteFetchAsApp will execute the given query, possibly disabling binlogs. // Should be called under RPCWrap. func (agent *ActionAgent) ExecuteFetchAsApp(ctx context.Context, query string, maxrows int) (*querypb.QueryResult, error) { // get a connection conn, err := agent.MysqlDaemon.GetAppConnection() if err != nil { return nil, err } defer conn.Recycle() result, err := conn.ExecuteFetch(query, maxrows, true /*wantFields*/) return sqltypes.ResultToProto3(result), err }
// QueryResultListToProto3 temporarily resurrected. func QueryResultListToProto3(results []sqltypes.Result) []*querypb.QueryResult { if len(results) == 0 { return nil } result := make([]*querypb.QueryResult, len(results)) for i := range results { result[i] = sqltypes.ResultToProto3(&results[i]) } return result }
func (s *server) ExecuteFetchAsApp(ctx context.Context, request *tabletmanagerdatapb.ExecuteFetchAsAppRequest) (*tabletmanagerdatapb.ExecuteFetchAsAppResponse, error) { ctx = callinfo.GRPCCallInfo(ctx) response := &tabletmanagerdatapb.ExecuteFetchAsAppResponse{} return response, s.agent.RPCWrap(ctx, actionnode.TabletActionExecuteFetchAsApp, request, response, func() error { qr, err := s.agent.ExecuteFetchAsApp(ctx, request.Query, int(request.MaxRows), request.WantFields) if err != nil { return err } response.Result = sqltypes.ResultToProto3(qr) return nil }) }
// Execute is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) Execute(ctx context.Context, request *vtgatepb.ExecuteRequest) (response *vtgatepb.ExecuteResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = withCallerIDContext(ctx, request.CallerId) bv, err := querytypes.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return nil, vterrors.ToGRPCError(err) } result, err := vtg.server.Execute(ctx, string(request.Query.Sql), bv, request.Keyspace, request.TabletType, request.Session, request.NotInTransaction) return &vtgatepb.ExecuteResponse{ Result: sqltypes.ResultToProto3(result), Session: request.Session, Error: vterrors.VtRPCErrorFromVtError(err), }, nil }
// Execute is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) Execute(ctx context.Context, request *vtgatepb.ExecuteRequest) (response *vtgatepb.ExecuteResponse, err error) { defer vtg.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.CallerId, callerid.NewImmediateCallerID("grpc client")) bv, err := tproto.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return nil, vterrors.ToGRPCError(err) } result, err := vtg.server.Execute(ctx, string(request.Query.Sql), bv, request.TabletType, request.Session, request.NotInTransaction) return &vtgatepb.ExecuteResponse{ Result: sqltypes.ResultToProto3(result), Session: request.Session, Error: vterrors.VtRPCErrorFromVtError(err), }, nil }
// Execute is part of the queryservice.QueryServer interface func (q *query) Execute(ctx context.Context, request *querypb.ExecuteRequest) (response *querypb.ExecuteResponse, err error) { defer q.server.HandlePanic(&err) ctx = callerid.NewContext(callinfo.GRPCCallInfo(ctx), request.EffectiveCallerId, request.ImmediateCallerId, ) bv, err := querytypes.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return nil, tabletserver.ToGRPCError(err) } result, err := q.server.Execute(ctx, request.Target, request.Query.Sql, bv, request.SessionId, request.TransactionId) if err != nil { return nil, tabletserver.ToGRPCError(err) } return &querypb.ExecuteResponse{ Result: sqltypes.ResultToProto3(result), }, nil }
// StreamExecute is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) StreamExecute(request *vtgatepb.StreamExecuteRequest, stream vtgateservicepb.Vitess_StreamExecuteServer) (err error) { defer vtg.server.HandlePanic(&err) ctx := withCallerIDContext(stream.Context(), request.CallerId) bv, err := querytypes.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return vterrors.ToGRPCError(err) } vtgErr := vtg.server.StreamExecute(ctx, string(request.Query.Sql), bv, request.Keyspace, request.TabletType, func(value *sqltypes.Result) error { return stream.Send(&vtgatepb.StreamExecuteResponse{ Result: sqltypes.ResultToProto3(value), }) }) return vterrors.ToGRPCError(vtgErr) }
// StreamExecute is part of the queryservice.QueryServer interface func (q *query) StreamExecute(request *querypb.StreamExecuteRequest, stream queryservicepb.Query_StreamExecuteServer) (err error) { defer q.server.HandlePanic(&err) ctx := callerid.NewContext(callinfo.GRPCCallInfo(stream.Context()), request.EffectiveCallerId, request.ImmediateCallerId, ) bv, err := querytypes.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return tabletserver.ToGRPCError(err) } if err := q.server.StreamExecute(ctx, request.Target, request.Query.Sql, bv, request.SessionId, func(reply *sqltypes.Result) error { return stream.Send(&querypb.StreamExecuteResponse{ Result: sqltypes.ResultToProto3(reply), }) }); err != nil { return tabletserver.ToGRPCError(err) } return nil }
// StreamExecute is the RPC version of vtgateservice.VTGateService method func (vtg *VTGate) StreamExecute(request *pb.StreamExecuteRequest, stream pbs.Vitess_StreamExecuteServer) (err error) { defer vtg.server.HandlePanic(&err) ctx := callerid.NewContext(callinfo.GRPCCallInfo(stream.Context()), request.CallerId, callerid.NewImmediateCallerID("grpc client")) bv, err := tproto.Proto3ToBindVariables(request.Query.BindVariables) if err != nil { return vterrors.ToGRPCError(err) } vtgErr := vtg.server.StreamExecute(ctx, string(request.Query.Sql), bv, request.TabletType, func(value *proto.QueryResult) error { return stream.Send(&pb.StreamExecuteResponse{ Result: sqltypes.ResultToProto3(value.Result), }) }) return vterrors.ToGRPCError(vtgErr) }
// ExecuteFetchAsDba will execute the given query, possibly disabling binlogs and reload schema. // Should be called under RPCWrap. func (agent *ActionAgent) ExecuteFetchAsDba(ctx context.Context, query string, dbName string, maxrows int, disableBinlogs bool, reloadSchema bool) (*querypb.QueryResult, error) { // get a connection conn, err := agent.MysqlDaemon.GetDbaConnection() if err != nil { return nil, err } defer conn.Close() // disable binlogs if necessary if disableBinlogs { _, err := conn.ExecuteFetch("SET sql_log_bin = OFF", 0, false) if err != nil { return nil, err } } if dbName != "" { // This execute might fail if db does not exist. // Error is ignored because given query might create this database. conn.ExecuteFetch("USE "+dbName, 1, false) } // run the query result, err := conn.ExecuteFetch(query, maxrows, true /*wantFields*/) // re-enable binlogs if necessary if disableBinlogs && !conn.IsClosed() { _, err := conn.ExecuteFetch("SET sql_log_bin = ON", 0, false) if err != nil { // if we can't reset the sql_log_bin flag, // let's just close the connection. conn.Close() } } if err == nil && reloadSchema { agent.QueryServiceControl.ReloadSchema() } return sqltypes.ResultToProto3(result), err }
// ExecuteFetchAsAllPrivs will execute the given query, possibly reloading schema. func (agent *ActionAgent) ExecuteFetchAsAllPrivs(ctx context.Context, query []byte, dbName string, maxrows int, reloadSchema bool) (*querypb.QueryResult, error) { // get a connection conn, err := agent.MysqlDaemon.GetAllPrivsConnection() if err != nil { return nil, err } defer conn.Close() if dbName != "" { // This execute might fail if db does not exist. // Error is ignored because given query might create this database. conn.ExecuteFetch("USE "+dbName, 1, false) } // run the query result, err := conn.ExecuteFetch(string(query), maxrows, true /*wantFields*/) if err == nil && reloadSchema { agent.QueryServiceControl.ReloadSchema(ctx) } return sqltypes.ResultToProto3(result), err }