vitess.io/vitess@v0.16.2/go/vt/proto/queryservice/queryservice_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.21.3
// source: queryservice.proto

package queryservice

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	binlogdata "vitess.io/vitess/go/vt/proto/binlogdata"
	query "vitess.io/vitess/go/vt/proto/query"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// QueryClient is the client API for Query service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type QueryClient interface {
	// Execute executes the specified SQL query (might be in a
	// transaction context, if Query.transaction_id is set).
	Execute(ctx context.Context, in *query.ExecuteRequest, opts ...grpc.CallOption) (*query.ExecuteResponse, error)
	// StreamExecute executes a streaming query. Use this method if the
	// query returns a large number of rows. The first QueryResult will
	// contain the Fields, subsequent QueryResult messages will contain
	// the rows.
	StreamExecute(ctx context.Context, in *query.StreamExecuteRequest, opts ...grpc.CallOption) (Query_StreamExecuteClient, error)
	// Begin a transaction.
	Begin(ctx context.Context, in *query.BeginRequest, opts ...grpc.CallOption) (*query.BeginResponse, error)
	// Commit a transaction.
	Commit(ctx context.Context, in *query.CommitRequest, opts ...grpc.CallOption) (*query.CommitResponse, error)
	// Rollback a transaction.
	Rollback(ctx context.Context, in *query.RollbackRequest, opts ...grpc.CallOption) (*query.RollbackResponse, error)
	// Prepare preares a transaction.
	Prepare(ctx context.Context, in *query.PrepareRequest, opts ...grpc.CallOption) (*query.PrepareResponse, error)
	// CommitPrepared commits a prepared transaction.
	CommitPrepared(ctx context.Context, in *query.CommitPreparedRequest, opts ...grpc.CallOption) (*query.CommitPreparedResponse, error)
	// RollbackPrepared rolls back a prepared transaction.
	RollbackPrepared(ctx context.Context, in *query.RollbackPreparedRequest, opts ...grpc.CallOption) (*query.RollbackPreparedResponse, error)
	// CreateTransaction creates the metadata for a 2pc transaction.
	CreateTransaction(ctx context.Context, in *query.CreateTransactionRequest, opts ...grpc.CallOption) (*query.CreateTransactionResponse, error)
	// StartCommit initiates a commit for a 2pc transaction.
	StartCommit(ctx context.Context, in *query.StartCommitRequest, opts ...grpc.CallOption) (*query.StartCommitResponse, error)
	// SetRollback marks the 2pc transaction for rollback.
	SetRollback(ctx context.Context, in *query.SetRollbackRequest, opts ...grpc.CallOption) (*query.SetRollbackResponse, error)
	// ConcludeTransaction marks the 2pc transaction as resolved.
	ConcludeTransaction(ctx context.Context, in *query.ConcludeTransactionRequest, opts ...grpc.CallOption) (*query.ConcludeTransactionResponse, error)
	// ReadTransaction returns the 2pc transaction info.
	ReadTransaction(ctx context.Context, in *query.ReadTransactionRequest, opts ...grpc.CallOption) (*query.ReadTransactionResponse, error)
	// BeginExecute executes a begin and the specified SQL query.
	BeginExecute(ctx context.Context, in *query.BeginExecuteRequest, opts ...grpc.CallOption) (*query.BeginExecuteResponse, error)
	// BeginStreamExecute executes a begin and the specified SQL query.
	BeginStreamExecute(ctx context.Context, in *query.BeginStreamExecuteRequest, opts ...grpc.CallOption) (Query_BeginStreamExecuteClient, error)
	// MessageStream streams messages from a message table.
	MessageStream(ctx context.Context, in *query.MessageStreamRequest, opts ...grpc.CallOption) (Query_MessageStreamClient, error)
	// MessageAck acks messages for a table.
	MessageAck(ctx context.Context, in *query.MessageAckRequest, opts ...grpc.CallOption) (*query.MessageAckResponse, error)
	// ReserveExecute executes a query on a reserved connection
	ReserveExecute(ctx context.Context, in *query.ReserveExecuteRequest, opts ...grpc.CallOption) (*query.ReserveExecuteResponse, error)
	// ReserveBeginExecute starts a transaction and executes a query in the transaction on a reserved connection
	ReserveBeginExecute(ctx context.Context, in *query.ReserveBeginExecuteRequest, opts ...grpc.CallOption) (*query.ReserveBeginExecuteResponse, error)
	// ReserveStreamExecute executes a streaming query on a reserved connection
	ReserveStreamExecute(ctx context.Context, in *query.ReserveStreamExecuteRequest, opts ...grpc.CallOption) (Query_ReserveStreamExecuteClient, error)
	// ReserveBeginStreamExecute starts a transaction and executes a streaming query in the transaction on a reserved connection
	ReserveBeginStreamExecute(ctx context.Context, in *query.ReserveBeginStreamExecuteRequest, opts ...grpc.CallOption) (Query_ReserveBeginStreamExecuteClient, error)
	// Release releases the connection
	Release(ctx context.Context, in *query.ReleaseRequest, opts ...grpc.CallOption) (*query.ReleaseResponse, error)
	// StreamHealth runs a streaming RPC to the tablet, that returns the
	// current health of the tablet on a regular basis.
	StreamHealth(ctx context.Context, in *query.StreamHealthRequest, opts ...grpc.CallOption) (Query_StreamHealthClient, error)
	// VStream streams vreplication events.
	VStream(ctx context.Context, in *binlogdata.VStreamRequest, opts ...grpc.CallOption) (Query_VStreamClient, error)
	// VStreamRows streams rows from the specified starting point.
	VStreamRows(ctx context.Context, in *binlogdata.VStreamRowsRequest, opts ...grpc.CallOption) (Query_VStreamRowsClient, error)
	// VStreamResults streams results along with the gtid of the snapshot.
	VStreamResults(ctx context.Context, in *binlogdata.VStreamResultsRequest, opts ...grpc.CallOption) (Query_VStreamResultsClient, error)
	// GetSchema returns the schema information.
	GetSchema(ctx context.Context, in *query.GetSchemaRequest, opts ...grpc.CallOption) (Query_GetSchemaClient, error)
}

type queryClient struct {
	cc grpc.ClientConnInterface
}

func NewQueryClient(cc grpc.ClientConnInterface) QueryClient {
	return &queryClient{cc}
}

func (c *queryClient) Execute(ctx context.Context, in *query.ExecuteRequest, opts ...grpc.CallOption) (*query.ExecuteResponse, error) {
	out := new(query.ExecuteResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Execute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) StreamExecute(ctx context.Context, in *query.StreamExecuteRequest, opts ...grpc.CallOption) (Query_StreamExecuteClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[0], "/queryservice.Query/StreamExecute", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryStreamExecuteClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_StreamExecuteClient interface {
	Recv() (*query.StreamExecuteResponse, error)
	grpc.ClientStream
}

type queryStreamExecuteClient struct {
	grpc.ClientStream
}

func (x *queryStreamExecuteClient) Recv() (*query.StreamExecuteResponse, error) {
	m := new(query.StreamExecuteResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) Begin(ctx context.Context, in *query.BeginRequest, opts ...grpc.CallOption) (*query.BeginResponse, error) {
	out := new(query.BeginResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Begin", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Commit(ctx context.Context, in *query.CommitRequest, opts ...grpc.CallOption) (*query.CommitResponse, error) {
	out := new(query.CommitResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Commit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Rollback(ctx context.Context, in *query.RollbackRequest, opts ...grpc.CallOption) (*query.RollbackResponse, error) {
	out := new(query.RollbackResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Rollback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) Prepare(ctx context.Context, in *query.PrepareRequest, opts ...grpc.CallOption) (*query.PrepareResponse, error) {
	out := new(query.PrepareResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Prepare", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CommitPrepared(ctx context.Context, in *query.CommitPreparedRequest, opts ...grpc.CallOption) (*query.CommitPreparedResponse, error) {
	out := new(query.CommitPreparedResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/CommitPrepared", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) RollbackPrepared(ctx context.Context, in *query.RollbackPreparedRequest, opts ...grpc.CallOption) (*query.RollbackPreparedResponse, error) {
	out := new(query.RollbackPreparedResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/RollbackPrepared", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) CreateTransaction(ctx context.Context, in *query.CreateTransactionRequest, opts ...grpc.CallOption) (*query.CreateTransactionResponse, error) {
	out := new(query.CreateTransactionResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/CreateTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) StartCommit(ctx context.Context, in *query.StartCommitRequest, opts ...grpc.CallOption) (*query.StartCommitResponse, error) {
	out := new(query.StartCommitResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/StartCommit", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) SetRollback(ctx context.Context, in *query.SetRollbackRequest, opts ...grpc.CallOption) (*query.SetRollbackResponse, error) {
	out := new(query.SetRollbackResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/SetRollback", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ConcludeTransaction(ctx context.Context, in *query.ConcludeTransactionRequest, opts ...grpc.CallOption) (*query.ConcludeTransactionResponse, error) {
	out := new(query.ConcludeTransactionResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/ConcludeTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ReadTransaction(ctx context.Context, in *query.ReadTransactionRequest, opts ...grpc.CallOption) (*query.ReadTransactionResponse, error) {
	out := new(query.ReadTransactionResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/ReadTransaction", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BeginExecute(ctx context.Context, in *query.BeginExecuteRequest, opts ...grpc.CallOption) (*query.BeginExecuteResponse, error) {
	out := new(query.BeginExecuteResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/BeginExecute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) BeginStreamExecute(ctx context.Context, in *query.BeginStreamExecuteRequest, opts ...grpc.CallOption) (Query_BeginStreamExecuteClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[1], "/queryservice.Query/BeginStreamExecute", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryBeginStreamExecuteClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_BeginStreamExecuteClient interface {
	Recv() (*query.BeginStreamExecuteResponse, error)
	grpc.ClientStream
}

type queryBeginStreamExecuteClient struct {
	grpc.ClientStream
}

func (x *queryBeginStreamExecuteClient) Recv() (*query.BeginStreamExecuteResponse, error) {
	m := new(query.BeginStreamExecuteResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) MessageStream(ctx context.Context, in *query.MessageStreamRequest, opts ...grpc.CallOption) (Query_MessageStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[2], "/queryservice.Query/MessageStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryMessageStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_MessageStreamClient interface {
	Recv() (*query.MessageStreamResponse, error)
	grpc.ClientStream
}

type queryMessageStreamClient struct {
	grpc.ClientStream
}

func (x *queryMessageStreamClient) Recv() (*query.MessageStreamResponse, error) {
	m := new(query.MessageStreamResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) MessageAck(ctx context.Context, in *query.MessageAckRequest, opts ...grpc.CallOption) (*query.MessageAckResponse, error) {
	out := new(query.MessageAckResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/MessageAck", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ReserveExecute(ctx context.Context, in *query.ReserveExecuteRequest, opts ...grpc.CallOption) (*query.ReserveExecuteResponse, error) {
	out := new(query.ReserveExecuteResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/ReserveExecute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ReserveBeginExecute(ctx context.Context, in *query.ReserveBeginExecuteRequest, opts ...grpc.CallOption) (*query.ReserveBeginExecuteResponse, error) {
	out := new(query.ReserveBeginExecuteResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/ReserveBeginExecute", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) ReserveStreamExecute(ctx context.Context, in *query.ReserveStreamExecuteRequest, opts ...grpc.CallOption) (Query_ReserveStreamExecuteClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[3], "/queryservice.Query/ReserveStreamExecute", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryReserveStreamExecuteClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_ReserveStreamExecuteClient interface {
	Recv() (*query.ReserveStreamExecuteResponse, error)
	grpc.ClientStream
}

type queryReserveStreamExecuteClient struct {
	grpc.ClientStream
}

func (x *queryReserveStreamExecuteClient) Recv() (*query.ReserveStreamExecuteResponse, error) {
	m := new(query.ReserveStreamExecuteResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) ReserveBeginStreamExecute(ctx context.Context, in *query.ReserveBeginStreamExecuteRequest, opts ...grpc.CallOption) (Query_ReserveBeginStreamExecuteClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[4], "/queryservice.Query/ReserveBeginStreamExecute", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryReserveBeginStreamExecuteClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_ReserveBeginStreamExecuteClient interface {
	Recv() (*query.ReserveBeginStreamExecuteResponse, error)
	grpc.ClientStream
}

type queryReserveBeginStreamExecuteClient struct {
	grpc.ClientStream
}

func (x *queryReserveBeginStreamExecuteClient) Recv() (*query.ReserveBeginStreamExecuteResponse, error) {
	m := new(query.ReserveBeginStreamExecuteResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) Release(ctx context.Context, in *query.ReleaseRequest, opts ...grpc.CallOption) (*query.ReleaseResponse, error) {
	out := new(query.ReleaseResponse)
	err := c.cc.Invoke(ctx, "/queryservice.Query/Release", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *queryClient) StreamHealth(ctx context.Context, in *query.StreamHealthRequest, opts ...grpc.CallOption) (Query_StreamHealthClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[5], "/queryservice.Query/StreamHealth", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryStreamHealthClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_StreamHealthClient interface {
	Recv() (*query.StreamHealthResponse, error)
	grpc.ClientStream
}

type queryStreamHealthClient struct {
	grpc.ClientStream
}

func (x *queryStreamHealthClient) Recv() (*query.StreamHealthResponse, error) {
	m := new(query.StreamHealthResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) VStream(ctx context.Context, in *binlogdata.VStreamRequest, opts ...grpc.CallOption) (Query_VStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[6], "/queryservice.Query/VStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryVStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_VStreamClient interface {
	Recv() (*binlogdata.VStreamResponse, error)
	grpc.ClientStream
}

type queryVStreamClient struct {
	grpc.ClientStream
}

func (x *queryVStreamClient) Recv() (*binlogdata.VStreamResponse, error) {
	m := new(binlogdata.VStreamResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) VStreamRows(ctx context.Context, in *binlogdata.VStreamRowsRequest, opts ...grpc.CallOption) (Query_VStreamRowsClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[7], "/queryservice.Query/VStreamRows", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryVStreamRowsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_VStreamRowsClient interface {
	Recv() (*binlogdata.VStreamRowsResponse, error)
	grpc.ClientStream
}

type queryVStreamRowsClient struct {
	grpc.ClientStream
}

func (x *queryVStreamRowsClient) Recv() (*binlogdata.VStreamRowsResponse, error) {
	m := new(binlogdata.VStreamRowsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) VStreamResults(ctx context.Context, in *binlogdata.VStreamResultsRequest, opts ...grpc.CallOption) (Query_VStreamResultsClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[8], "/queryservice.Query/VStreamResults", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryVStreamResultsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_VStreamResultsClient interface {
	Recv() (*binlogdata.VStreamResultsResponse, error)
	grpc.ClientStream
}

type queryVStreamResultsClient struct {
	grpc.ClientStream
}

func (x *queryVStreamResultsClient) Recv() (*binlogdata.VStreamResultsResponse, error) {
	m := new(binlogdata.VStreamResultsResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *queryClient) GetSchema(ctx context.Context, in *query.GetSchemaRequest, opts ...grpc.CallOption) (Query_GetSchemaClient, error) {
	stream, err := c.cc.NewStream(ctx, &Query_ServiceDesc.Streams[9], "/queryservice.Query/GetSchema", opts...)
	if err != nil {
		return nil, err
	}
	x := &queryGetSchemaClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Query_GetSchemaClient interface {
	Recv() (*query.GetSchemaResponse, error)
	grpc.ClientStream
}

type queryGetSchemaClient struct {
	grpc.ClientStream
}

func (x *queryGetSchemaClient) Recv() (*query.GetSchemaResponse, error) {
	m := new(query.GetSchemaResponse)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// QueryServer is the server API for Query service.
// All implementations must embed UnimplementedQueryServer
// for forward compatibility
type QueryServer interface {
	// Execute executes the specified SQL query (might be in a
	// transaction context, if Query.transaction_id is set).
	Execute(context.Context, *query.ExecuteRequest) (*query.ExecuteResponse, error)
	// StreamExecute executes a streaming query. Use this method if the
	// query returns a large number of rows. The first QueryResult will
	// contain the Fields, subsequent QueryResult messages will contain
	// the rows.
	StreamExecute(*query.StreamExecuteRequest, Query_StreamExecuteServer) error
	// Begin a transaction.
	Begin(context.Context, *query.BeginRequest) (*query.BeginResponse, error)
	// Commit a transaction.
	Commit(context.Context, *query.CommitRequest) (*query.CommitResponse, error)
	// Rollback a transaction.
	Rollback(context.Context, *query.RollbackRequest) (*query.RollbackResponse, error)
	// Prepare preares a transaction.
	Prepare(context.Context, *query.PrepareRequest) (*query.PrepareResponse, error)
	// CommitPrepared commits a prepared transaction.
	CommitPrepared(context.Context, *query.CommitPreparedRequest) (*query.CommitPreparedResponse, error)
	// RollbackPrepared rolls back a prepared transaction.
	RollbackPrepared(context.Context, *query.RollbackPreparedRequest) (*query.RollbackPreparedResponse, error)
	// CreateTransaction creates the metadata for a 2pc transaction.
	CreateTransaction(context.Context, *query.CreateTransactionRequest) (*query.CreateTransactionResponse, error)
	// StartCommit initiates a commit for a 2pc transaction.
	StartCommit(context.Context, *query.StartCommitRequest) (*query.StartCommitResponse, error)
	// SetRollback marks the 2pc transaction for rollback.
	SetRollback(context.Context, *query.SetRollbackRequest) (*query.SetRollbackResponse, error)
	// ConcludeTransaction marks the 2pc transaction as resolved.
	ConcludeTransaction(context.Context, *query.ConcludeTransactionRequest) (*query.ConcludeTransactionResponse, error)
	// ReadTransaction returns the 2pc transaction info.
	ReadTransaction(context.Context, *query.ReadTransactionRequest) (*query.ReadTransactionResponse, error)
	// BeginExecute executes a begin and the specified SQL query.
	BeginExecute(context.Context, *query.BeginExecuteRequest) (*query.BeginExecuteResponse, error)
	// BeginStreamExecute executes a begin and the specified SQL query.
	BeginStreamExecute(*query.BeginStreamExecuteRequest, Query_BeginStreamExecuteServer) error
	// MessageStream streams messages from a message table.
	MessageStream(*query.MessageStreamRequest, Query_MessageStreamServer) error
	// MessageAck acks messages for a table.
	MessageAck(context.Context, *query.MessageAckRequest) (*query.MessageAckResponse, error)
	// ReserveExecute executes a query on a reserved connection
	ReserveExecute(context.Context, *query.ReserveExecuteRequest) (*query.ReserveExecuteResponse, error)
	// ReserveBeginExecute starts a transaction and executes a query in the transaction on a reserved connection
	ReserveBeginExecute(context.Context, *query.ReserveBeginExecuteRequest) (*query.ReserveBeginExecuteResponse, error)
	// ReserveStreamExecute executes a streaming query on a reserved connection
	ReserveStreamExecute(*query.ReserveStreamExecuteRequest, Query_ReserveStreamExecuteServer) error
	// ReserveBeginStreamExecute starts a transaction and executes a streaming query in the transaction on a reserved connection
	ReserveBeginStreamExecute(*query.ReserveBeginStreamExecuteRequest, Query_ReserveBeginStreamExecuteServer) error
	// Release releases the connection
	Release(context.Context, *query.ReleaseRequest) (*query.ReleaseResponse, error)
	// StreamHealth runs a streaming RPC to the tablet, that returns the
	// current health of the tablet on a regular basis.
	StreamHealth(*query.StreamHealthRequest, Query_StreamHealthServer) error
	// VStream streams vreplication events.
	VStream(*binlogdata.VStreamRequest, Query_VStreamServer) error
	// VStreamRows streams rows from the specified starting point.
	VStreamRows(*binlogdata.VStreamRowsRequest, Query_VStreamRowsServer) error
	// VStreamResults streams results along with the gtid of the snapshot.
	VStreamResults(*binlogdata.VStreamResultsRequest, Query_VStreamResultsServer) error
	// GetSchema returns the schema information.
	GetSchema(*query.GetSchemaRequest, Query_GetSchemaServer) error
	mustEmbedUnimplementedQueryServer()
}

// UnimplementedQueryServer must be embedded to have forward compatible implementations.
type UnimplementedQueryServer struct {
}

func (UnimplementedQueryServer) Execute(context.Context, *query.ExecuteRequest) (*query.ExecuteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Execute not implemented")
}
func (UnimplementedQueryServer) StreamExecute(*query.StreamExecuteRequest, Query_StreamExecuteServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamExecute not implemented")
}
func (UnimplementedQueryServer) Begin(context.Context, *query.BeginRequest) (*query.BeginResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Begin not implemented")
}
func (UnimplementedQueryServer) Commit(context.Context, *query.CommitRequest) (*query.CommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Commit not implemented")
}
func (UnimplementedQueryServer) Rollback(context.Context, *query.RollbackRequest) (*query.RollbackResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Rollback not implemented")
}
func (UnimplementedQueryServer) Prepare(context.Context, *query.PrepareRequest) (*query.PrepareResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Prepare not implemented")
}
func (UnimplementedQueryServer) CommitPrepared(context.Context, *query.CommitPreparedRequest) (*query.CommitPreparedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CommitPrepared not implemented")
}
func (UnimplementedQueryServer) RollbackPrepared(context.Context, *query.RollbackPreparedRequest) (*query.RollbackPreparedResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RollbackPrepared not implemented")
}
func (UnimplementedQueryServer) CreateTransaction(context.Context, *query.CreateTransactionRequest) (*query.CreateTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTransaction not implemented")
}
func (UnimplementedQueryServer) StartCommit(context.Context, *query.StartCommitRequest) (*query.StartCommitResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartCommit not implemented")
}
func (UnimplementedQueryServer) SetRollback(context.Context, *query.SetRollbackRequest) (*query.SetRollbackResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetRollback not implemented")
}
func (UnimplementedQueryServer) ConcludeTransaction(context.Context, *query.ConcludeTransactionRequest) (*query.ConcludeTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConcludeTransaction not implemented")
}
func (UnimplementedQueryServer) ReadTransaction(context.Context, *query.ReadTransactionRequest) (*query.ReadTransactionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReadTransaction not implemented")
}
func (UnimplementedQueryServer) BeginExecute(context.Context, *query.BeginExecuteRequest) (*query.BeginExecuteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BeginExecute not implemented")
}
func (UnimplementedQueryServer) BeginStreamExecute(*query.BeginStreamExecuteRequest, Query_BeginStreamExecuteServer) error {
	return status.Errorf(codes.Unimplemented, "method BeginStreamExecute not implemented")
}
func (UnimplementedQueryServer) MessageStream(*query.MessageStreamRequest, Query_MessageStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method MessageStream not implemented")
}
func (UnimplementedQueryServer) MessageAck(context.Context, *query.MessageAckRequest) (*query.MessageAckResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method MessageAck not implemented")
}
func (UnimplementedQueryServer) ReserveExecute(context.Context, *query.ReserveExecuteRequest) (*query.ReserveExecuteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReserveExecute not implemented")
}
func (UnimplementedQueryServer) ReserveBeginExecute(context.Context, *query.ReserveBeginExecuteRequest) (*query.ReserveBeginExecuteResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReserveBeginExecute not implemented")
}
func (UnimplementedQueryServer) ReserveStreamExecute(*query.ReserveStreamExecuteRequest, Query_ReserveStreamExecuteServer) error {
	return status.Errorf(codes.Unimplemented, "method ReserveStreamExecute not implemented")
}
func (UnimplementedQueryServer) ReserveBeginStreamExecute(*query.ReserveBeginStreamExecuteRequest, Query_ReserveBeginStreamExecuteServer) error {
	return status.Errorf(codes.Unimplemented, "method ReserveBeginStreamExecute not implemented")
}
func (UnimplementedQueryServer) Release(context.Context, *query.ReleaseRequest) (*query.ReleaseResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Release not implemented")
}
func (UnimplementedQueryServer) StreamHealth(*query.StreamHealthRequest, Query_StreamHealthServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamHealth not implemented")
}
func (UnimplementedQueryServer) VStream(*binlogdata.VStreamRequest, Query_VStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method VStream not implemented")
}
func (UnimplementedQueryServer) VStreamRows(*binlogdata.VStreamRowsRequest, Query_VStreamRowsServer) error {
	return status.Errorf(codes.Unimplemented, "method VStreamRows not implemented")
}
func (UnimplementedQueryServer) VStreamResults(*binlogdata.VStreamResultsRequest, Query_VStreamResultsServer) error {
	return status.Errorf(codes.Unimplemented, "method VStreamResults not implemented")
}
func (UnimplementedQueryServer) GetSchema(*query.GetSchemaRequest, Query_GetSchemaServer) error {
	return status.Errorf(codes.Unimplemented, "method GetSchema not implemented")
}
func (UnimplementedQueryServer) mustEmbedUnimplementedQueryServer() {}

// UnsafeQueryServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to QueryServer will
// result in compilation errors.
type UnsafeQueryServer interface {
	mustEmbedUnimplementedQueryServer()
}

func RegisterQueryServer(s grpc.ServiceRegistrar, srv QueryServer) {
	s.RegisterService(&Query_ServiceDesc, srv)
}

func _Query_Execute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ExecuteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Execute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Execute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Execute(ctx, req.(*query.ExecuteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_StreamExecute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.StreamExecuteRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).StreamExecute(m, &queryStreamExecuteServer{stream})
}

type Query_StreamExecuteServer interface {
	Send(*query.StreamExecuteResponse) error
	grpc.ServerStream
}

type queryStreamExecuteServer struct {
	grpc.ServerStream
}

func (x *queryStreamExecuteServer) Send(m *query.StreamExecuteResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_Begin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.BeginRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Begin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Begin",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Begin(ctx, req.(*query.BeginRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Commit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.CommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Commit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Commit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Commit(ctx, req.(*query.CommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Rollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.RollbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Rollback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Rollback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Rollback(ctx, req.(*query.RollbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_Prepare_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.PrepareRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Prepare(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Prepare",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Prepare(ctx, req.(*query.PrepareRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CommitPrepared_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.CommitPreparedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CommitPrepared(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/CommitPrepared",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CommitPrepared(ctx, req.(*query.CommitPreparedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_RollbackPrepared_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.RollbackPreparedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).RollbackPrepared(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/RollbackPrepared",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).RollbackPrepared(ctx, req.(*query.RollbackPreparedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_CreateTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.CreateTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).CreateTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/CreateTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).CreateTransaction(ctx, req.(*query.CreateTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_StartCommit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.StartCommitRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).StartCommit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/StartCommit",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).StartCommit(ctx, req.(*query.StartCommitRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_SetRollback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.SetRollbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).SetRollback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/SetRollback",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).SetRollback(ctx, req.(*query.SetRollbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ConcludeTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ConcludeTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ConcludeTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/ConcludeTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ConcludeTransaction(ctx, req.(*query.ConcludeTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ReadTransaction_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ReadTransactionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ReadTransaction(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/ReadTransaction",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ReadTransaction(ctx, req.(*query.ReadTransactionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BeginExecute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.BeginExecuteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).BeginExecute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/BeginExecute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).BeginExecute(ctx, req.(*query.BeginExecuteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_BeginStreamExecute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.BeginStreamExecuteRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).BeginStreamExecute(m, &queryBeginStreamExecuteServer{stream})
}

type Query_BeginStreamExecuteServer interface {
	Send(*query.BeginStreamExecuteResponse) error
	grpc.ServerStream
}

type queryBeginStreamExecuteServer struct {
	grpc.ServerStream
}

func (x *queryBeginStreamExecuteServer) Send(m *query.BeginStreamExecuteResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_MessageStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.MessageStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).MessageStream(m, &queryMessageStreamServer{stream})
}

type Query_MessageStreamServer interface {
	Send(*query.MessageStreamResponse) error
	grpc.ServerStream
}

type queryMessageStreamServer struct {
	grpc.ServerStream
}

func (x *queryMessageStreamServer) Send(m *query.MessageStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_MessageAck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.MessageAckRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).MessageAck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/MessageAck",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).MessageAck(ctx, req.(*query.MessageAckRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ReserveExecute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ReserveExecuteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ReserveExecute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/ReserveExecute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ReserveExecute(ctx, req.(*query.ReserveExecuteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ReserveBeginExecute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ReserveBeginExecuteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).ReserveBeginExecute(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/ReserveBeginExecute",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).ReserveBeginExecute(ctx, req.(*query.ReserveBeginExecuteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_ReserveStreamExecute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.ReserveStreamExecuteRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).ReserveStreamExecute(m, &queryReserveStreamExecuteServer{stream})
}

type Query_ReserveStreamExecuteServer interface {
	Send(*query.ReserveStreamExecuteResponse) error
	grpc.ServerStream
}

type queryReserveStreamExecuteServer struct {
	grpc.ServerStream
}

func (x *queryReserveStreamExecuteServer) Send(m *query.ReserveStreamExecuteResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_ReserveBeginStreamExecute_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.ReserveBeginStreamExecuteRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).ReserveBeginStreamExecute(m, &queryReserveBeginStreamExecuteServer{stream})
}

type Query_ReserveBeginStreamExecuteServer interface {
	Send(*query.ReserveBeginStreamExecuteResponse) error
	grpc.ServerStream
}

type queryReserveBeginStreamExecuteServer struct {
	grpc.ServerStream
}

func (x *queryReserveBeginStreamExecuteServer) Send(m *query.ReserveBeginStreamExecuteResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_Release_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(query.ReleaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(QueryServer).Release(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/queryservice.Query/Release",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(QueryServer).Release(ctx, req.(*query.ReleaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Query_StreamHealth_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.StreamHealthRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).StreamHealth(m, &queryStreamHealthServer{stream})
}

type Query_StreamHealthServer interface {
	Send(*query.StreamHealthResponse) error
	grpc.ServerStream
}

type queryStreamHealthServer struct {
	grpc.ServerStream
}

func (x *queryStreamHealthServer) Send(m *query.StreamHealthResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_VStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(binlogdata.VStreamRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).VStream(m, &queryVStreamServer{stream})
}

type Query_VStreamServer interface {
	Send(*binlogdata.VStreamResponse) error
	grpc.ServerStream
}

type queryVStreamServer struct {
	grpc.ServerStream
}

func (x *queryVStreamServer) Send(m *binlogdata.VStreamResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_VStreamRows_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(binlogdata.VStreamRowsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).VStreamRows(m, &queryVStreamRowsServer{stream})
}

type Query_VStreamRowsServer interface {
	Send(*binlogdata.VStreamRowsResponse) error
	grpc.ServerStream
}

type queryVStreamRowsServer struct {
	grpc.ServerStream
}

func (x *queryVStreamRowsServer) Send(m *binlogdata.VStreamRowsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_VStreamResults_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(binlogdata.VStreamResultsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).VStreamResults(m, &queryVStreamResultsServer{stream})
}

type Query_VStreamResultsServer interface {
	Send(*binlogdata.VStreamResultsResponse) error
	grpc.ServerStream
}

type queryVStreamResultsServer struct {
	grpc.ServerStream
}

func (x *queryVStreamResultsServer) Send(m *binlogdata.VStreamResultsResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _Query_GetSchema_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(query.GetSchemaRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(QueryServer).GetSchema(m, &queryGetSchemaServer{stream})
}

type Query_GetSchemaServer interface {
	Send(*query.GetSchemaResponse) error
	grpc.ServerStream
}

type queryGetSchemaServer struct {
	grpc.ServerStream
}

func (x *queryGetSchemaServer) Send(m *query.GetSchemaResponse) error {
	return x.ServerStream.SendMsg(m)
}

// Query_ServiceDesc is the grpc.ServiceDesc for Query service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Query_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "queryservice.Query",
	HandlerType: (*QueryServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Execute",
			Handler:    _Query_Execute_Handler,
		},
		{
			MethodName: "Begin",
			Handler:    _Query_Begin_Handler,
		},
		{
			MethodName: "Commit",
			Handler:    _Query_Commit_Handler,
		},
		{
			MethodName: "Rollback",
			Handler:    _Query_Rollback_Handler,
		},
		{
			MethodName: "Prepare",
			Handler:    _Query_Prepare_Handler,
		},
		{
			MethodName: "CommitPrepared",
			Handler:    _Query_CommitPrepared_Handler,
		},
		{
			MethodName: "RollbackPrepared",
			Handler:    _Query_RollbackPrepared_Handler,
		},
		{
			MethodName: "CreateTransaction",
			Handler:    _Query_CreateTransaction_Handler,
		},
		{
			MethodName: "StartCommit",
			Handler:    _Query_StartCommit_Handler,
		},
		{
			MethodName: "SetRollback",
			Handler:    _Query_SetRollback_Handler,
		},
		{
			MethodName: "ConcludeTransaction",
			Handler:    _Query_ConcludeTransaction_Handler,
		},
		{
			MethodName: "ReadTransaction",
			Handler:    _Query_ReadTransaction_Handler,
		},
		{
			MethodName: "BeginExecute",
			Handler:    _Query_BeginExecute_Handler,
		},
		{
			MethodName: "MessageAck",
			Handler:    _Query_MessageAck_Handler,
		},
		{
			MethodName: "ReserveExecute",
			Handler:    _Query_ReserveExecute_Handler,
		},
		{
			MethodName: "ReserveBeginExecute",
			Handler:    _Query_ReserveBeginExecute_Handler,
		},
		{
			MethodName: "Release",
			Handler:    _Query_Release_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamExecute",
			Handler:       _Query_StreamExecute_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "BeginStreamExecute",
			Handler:       _Query_BeginStreamExecute_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "MessageStream",
			Handler:       _Query_MessageStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ReserveStreamExecute",
			Handler:       _Query_ReserveStreamExecute_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ReserveBeginStreamExecute",
			Handler:       _Query_ReserveBeginStreamExecute_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "StreamHealth",
			Handler:       _Query_StreamHealth_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "VStream",
			Handler:       _Query_VStream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "VStreamRows",
			Handler:       _Query_VStreamRows_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "VStreamResults",
			Handler:       _Query_VStreamResults_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "GetSchema",
			Handler:       _Query_GetSchema_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "queryservice.proto",
}