const (
	QueryService_CreateSession_FullMethodName       = "/Ydb.Query.V1.QueryService/CreateSession"
	QueryService_DeleteSession_FullMethodName       = "/Ydb.Query.V1.QueryService/DeleteSession"
	QueryService_AttachSession_FullMethodName       = "/Ydb.Query.V1.QueryService/AttachSession"
	QueryService_BeginTransaction_FullMethodName    = "/Ydb.Query.V1.QueryService/BeginTransaction"
	QueryService_CommitTransaction_FullMethodName   = "/Ydb.Query.V1.QueryService/CommitTransaction"
	QueryService_RollbackTransaction_FullMethodName = "/Ydb.Query.V1.QueryService/RollbackTransaction"
	QueryService_ExecuteQuery_FullMethodName        = "/Ydb.Query.V1.QueryService/ExecuteQuery"
	QueryService_ExecuteScript_FullMethodName       = "/Ydb.Query.V1.QueryService/ExecuteScript"
	QueryService_FetchScriptResults_FullMethodName  = "/Ydb.Query.V1.QueryService/FetchScriptResults"
)

var File_ydb_query_v1_proto protoreflect.FileDescriptor

var QueryService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "Ydb.Query.V1.QueryService",
	HandlerType: (*QueryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSession",
			Handler:    _QueryService_CreateSession_Handler,
		},
		{
			MethodName: "DeleteSession",
			Handler:    _QueryService_DeleteSession_Handler,
		},
		{
			MethodName: "BeginTransaction",
			Handler:    _QueryService_BeginTransaction_Handler,
		},
		{
			MethodName: "CommitTransaction",
			Handler:    _QueryService_CommitTransaction_Handler,
		},
		{
			MethodName: "RollbackTransaction",
			Handler:    _QueryService_RollbackTransaction_Handler,
		},
		{
			MethodName: "ExecuteScript",
			Handler:    _QueryService_ExecuteScript_Handler,
		},
		{
			MethodName: "FetchScriptResults",
			Handler:    _QueryService_FetchScriptResults_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "AttachSession",
			Handler:       _QueryService_AttachSession_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "ExecuteQuery",
			Handler:       _QueryService_ExecuteQuery_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "ydb_query_v1.proto",
}

type QueryServiceClient interface {
	// Sessions are basic primitives for communicating with YDB Query Service. The are similar to
	// connections for classic relational DBs. Sessions serve three main purposes:
	// 1. Provide a flow control for DB requests with limited number of active channels.
	// 2. Distribute load evenly across multiple DB nodes.
	// 3. Store state for volatile stateful operations, such as short-living transactions.
	CreateSession(ctx context.Context, in *Ydb_Query.CreateSessionRequest, opts ...grpc.CallOption) (*Ydb_Query.CreateSessionResponse, error)
	DeleteSession(ctx context.Context, in *Ydb_Query.DeleteSessionRequest, opts ...grpc.CallOption) (*Ydb_Query.DeleteSessionResponse, error)
	AttachSession(ctx context.Context, in *Ydb_Query.AttachSessionRequest, opts ...grpc.CallOption) (QueryService_AttachSessionClient, error)
	// Short-living transactions allow transactional execution of several queries, including support
	// for interactive transactions. Transaction control can be implemented via flags in ExecuteQuery
	// call (recommended), or via explicit calls to Begin/Commit/RollbackTransaction.
	BeginTransaction(ctx context.Context, in *Ydb_Query.BeginTransactionRequest, opts ...grpc.CallOption) (*Ydb_Query.BeginTransactionResponse, error)
	CommitTransaction(ctx context.Context, in *Ydb_Query.CommitTransactionRequest, opts ...grpc.CallOption) (*Ydb_Query.CommitTransactionResponse, error)
	RollbackTransaction(ctx context.Context, in *Ydb_Query.RollbackTransactionRequest, opts ...grpc.CallOption) (*Ydb_Query.RollbackTransactionResponse, error)
	// Execute interactive query in a specified short-living transaction.
	// YDB query can contain DML, DDL and DCL statements. Supported mix of different statement types depends
	// on the chosen transaction type.
	// In case of error, including transport errors such as interrupted stream, whole transaction
	// needs to be retried. For non-idempotent transaction, a custom client logic is required to
	// retry conditionally retriable statuses, when transaction execution state is unknown.
	ExecuteQuery(ctx context.Context, in *Ydb_Query.ExecuteQueryRequest, opts ...grpc.CallOption) (QueryService_ExecuteQueryClient, error)
	// Execute long-running script.
	// YDB scripts can contain all type of statements, including TCL statements. This way you can execute multiple
	// transactions in a single YDB script.
	// ExecuteScript call returns long-running Ydb.Operation object with:
	//
	//	operation.metadata = ExecuteScriptMetadata
	//	operation.result = Empty
	//
	// Script execution metadata contains all information about current execution state, including
	// execution_id, execution statistics and result sets info.
	// You can use standard operation methods such as Get/Cancel/Forget/ListOperations to work with script executions.
	// Script can be executed as persistent, in which case all execution information and results will be stored
	// persistently and available after successful or unsuccessful execution.
	ExecuteScript(ctx context.Context, in *Ydb_Query.ExecuteScriptRequest, opts ...grpc.CallOption) (*Ydb_Operations.Operation, error)
	// Fetch results for script execution using fetch_token for continuation.
	// For script with multiple result sets, parts of different results sets are interleaved in responses.
	// For persistent scripts, you can fetch results in specific position of specific result set using
	// position instead of fetch_token.
	FetchScriptResults(ctx context.Context, in *Ydb_Query.FetchScriptResultsRequest, opts ...grpc.CallOption) (*Ydb_Query.FetchScriptResultsResponse, error)
}

type QueryServiceServer interface {
	// Sessions are basic primitives for communicating with YDB Query Service. The are similar to
	// connections for classic relational DBs. Sessions serve three main purposes:
	// 1. Provide a flow control for DB requests with limited number of active channels.
	// 2. Distribute load evenly across multiple DB nodes.
	// 3. Store state for volatile stateful operations, such as short-living transactions.
	CreateSession(context.Context, *Ydb_Query.CreateSessionRequest) (*Ydb_Query.CreateSessionResponse, error)
	DeleteSession(context.Context, *Ydb_Query.DeleteSessionRequest) (*Ydb_Query.DeleteSessionResponse, error)
	AttachSession(*Ydb_Query.AttachSessionRequest, QueryService_AttachSessionServer) error
	// Short-living transactions allow transactional execution of several queries, including support
	// for interactive transactions. Transaction control can be implemented via flags in ExecuteQuery
	// call (recommended), or via explicit calls to Begin/Commit/RollbackTransaction.
	BeginTransaction(context.Context, *Ydb_Query.BeginTransactionRequest) (*Ydb_Query.BeginTransactionResponse, error)
	CommitTransaction(context.Context, *Ydb_Query.CommitTransactionRequest) (*Ydb_Query.CommitTransactionResponse, error)
	RollbackTransaction(context.Context, *Ydb_Query.RollbackTransactionRequest) (*Ydb_Query.RollbackTransactionResponse, error)
	// Execute interactive query in a specified short-living transaction.
	// YDB query can contain DML, DDL and DCL statements. Supported mix of different statement types depends
	// on the chosen transaction type.
	// In case of error, including transport errors such as interrupted stream, whole transaction
	// needs to be retried. For non-idempotent transaction, a custom client logic is required to
	// retry conditionally retriable statuses, when transaction execution state is unknown.
	ExecuteQuery(*Ydb_Query.ExecuteQueryRequest, QueryService_ExecuteQueryServer) error
	// Execute long-running script.
	// YDB scripts can contain all type of statements, including TCL statements. This way you can execute multiple
	// transactions in a single YDB script.
	// ExecuteScript call returns long-running Ydb.Operation object with:
	//
	//	operation.metadata = ExecuteScriptMetadata
	//	operation.result = Empty
	//
	// Script execution metadata contains all information about current execution state, including
	// execution_id, execution statistics and result sets info.
	// You can use standard operation methods such as Get/Cancel/Forget/ListOperations to work with script executions.
	// Script can be executed as persistent, in which case all execution information and results will be stored
	// persistently and available after successful or unsuccessful execution.
	ExecuteScript(context.Context, *Ydb_Query.ExecuteScriptRequest) (*Ydb_Operations.Operation, error)
	// Fetch results for script execution using fetch_token for continuation.
	// For script with multiple result sets, parts of different results sets are interleaved in responses.
	// For persistent scripts, you can fetch results in specific position of specific result set using
	// position instead of fetch_token.
	FetchScriptResults(context.Context, *Ydb_Query.FetchScriptResultsRequest) (*Ydb_Query.FetchScriptResultsResponse, error)
	// contains filtered or unexported methods
}

type QueryService_AttachSessionClient interface {
	Recv() (*Ydb_Query.SessionState, error)
	grpc.ClientStream
}

type QueryService_AttachSessionServer interface {
	Send(*Ydb_Query.SessionState) error
	grpc.ServerStream
}

type QueryService_ExecuteQueryClient interface {
	Recv() (*Ydb_Query.ExecuteQueryResponsePart, error)
	grpc.ClientStream
}

type QueryService_ExecuteQueryServer interface {
	Send(*Ydb_Query.ExecuteQueryResponsePart) error
	grpc.ServerStream
}

type UnimplementedQueryServiceServer struct {
}

type UnsafeQueryServiceServer interface {
	// contains filtered or unexported methods
}