tech.ydb.proto.query.v1.QueryServiceGrpc Maven / Gradle / Ivy
package tech.ydb.proto.query.v1;
import static io.grpc.MethodDescriptor.generateFullMethodName;
/**
*/
@javax.annotation.Generated(
value = "by gRPC proto compiler (version 1.59.1)",
comments = "Source: ydb_query_v1.proto")
@io.grpc.stub.annotations.GrpcGenerated
public final class QueryServiceGrpc {
private QueryServiceGrpc() {}
public static final java.lang.String SERVICE_NAME = "Ydb.Query.V1.QueryService";
// Static method descriptors that strictly reflect the proto.
private static volatile io.grpc.MethodDescriptor getCreateSessionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CreateSession",
requestType = tech.ydb.proto.query.YdbQuery.CreateSessionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.CreateSessionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCreateSessionMethod() {
io.grpc.MethodDescriptor getCreateSessionMethod;
if ((getCreateSessionMethod = QueryServiceGrpc.getCreateSessionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getCreateSessionMethod = QueryServiceGrpc.getCreateSessionMethod) == null) {
QueryServiceGrpc.getCreateSessionMethod = getCreateSessionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateSession"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.CreateSessionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.CreateSessionResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("CreateSession"))
.build();
}
}
}
return getCreateSessionMethod;
}
private static volatile io.grpc.MethodDescriptor getDeleteSessionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "DeleteSession",
requestType = tech.ydb.proto.query.YdbQuery.DeleteSessionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.DeleteSessionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getDeleteSessionMethod() {
io.grpc.MethodDescriptor getDeleteSessionMethod;
if ((getDeleteSessionMethod = QueryServiceGrpc.getDeleteSessionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getDeleteSessionMethod = QueryServiceGrpc.getDeleteSessionMethod) == null) {
QueryServiceGrpc.getDeleteSessionMethod = getDeleteSessionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteSession"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.DeleteSessionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.DeleteSessionResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("DeleteSession"))
.build();
}
}
}
return getDeleteSessionMethod;
}
private static volatile io.grpc.MethodDescriptor getAttachSessionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "AttachSession",
requestType = tech.ydb.proto.query.YdbQuery.AttachSessionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.SessionState.class,
methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
public static io.grpc.MethodDescriptor getAttachSessionMethod() {
io.grpc.MethodDescriptor getAttachSessionMethod;
if ((getAttachSessionMethod = QueryServiceGrpc.getAttachSessionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getAttachSessionMethod = QueryServiceGrpc.getAttachSessionMethod) == null) {
QueryServiceGrpc.getAttachSessionMethod = getAttachSessionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "AttachSession"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.AttachSessionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.SessionState.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("AttachSession"))
.build();
}
}
}
return getAttachSessionMethod;
}
private static volatile io.grpc.MethodDescriptor getBeginTransactionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "BeginTransaction",
requestType = tech.ydb.proto.query.YdbQuery.BeginTransactionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.BeginTransactionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getBeginTransactionMethod() {
io.grpc.MethodDescriptor getBeginTransactionMethod;
if ((getBeginTransactionMethod = QueryServiceGrpc.getBeginTransactionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getBeginTransactionMethod = QueryServiceGrpc.getBeginTransactionMethod) == null) {
QueryServiceGrpc.getBeginTransactionMethod = getBeginTransactionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "BeginTransaction"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.BeginTransactionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.BeginTransactionResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("BeginTransaction"))
.build();
}
}
}
return getBeginTransactionMethod;
}
private static volatile io.grpc.MethodDescriptor getCommitTransactionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "CommitTransaction",
requestType = tech.ydb.proto.query.YdbQuery.CommitTransactionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.CommitTransactionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getCommitTransactionMethod() {
io.grpc.MethodDescriptor getCommitTransactionMethod;
if ((getCommitTransactionMethod = QueryServiceGrpc.getCommitTransactionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getCommitTransactionMethod = QueryServiceGrpc.getCommitTransactionMethod) == null) {
QueryServiceGrpc.getCommitTransactionMethod = getCommitTransactionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "CommitTransaction"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.CommitTransactionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.CommitTransactionResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("CommitTransaction"))
.build();
}
}
}
return getCommitTransactionMethod;
}
private static volatile io.grpc.MethodDescriptor getRollbackTransactionMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "RollbackTransaction",
requestType = tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.RollbackTransactionResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getRollbackTransactionMethod() {
io.grpc.MethodDescriptor getRollbackTransactionMethod;
if ((getRollbackTransactionMethod = QueryServiceGrpc.getRollbackTransactionMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getRollbackTransactionMethod = QueryServiceGrpc.getRollbackTransactionMethod) == null) {
QueryServiceGrpc.getRollbackTransactionMethod = getRollbackTransactionMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "RollbackTransaction"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.RollbackTransactionResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("RollbackTransaction"))
.build();
}
}
}
return getRollbackTransactionMethod;
}
private static volatile io.grpc.MethodDescriptor getExecuteQueryMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ExecuteQuery",
requestType = tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.ExecuteQueryResponsePart.class,
methodType = io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
public static io.grpc.MethodDescriptor getExecuteQueryMethod() {
io.grpc.MethodDescriptor getExecuteQueryMethod;
if ((getExecuteQueryMethod = QueryServiceGrpc.getExecuteQueryMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getExecuteQueryMethod = QueryServiceGrpc.getExecuteQueryMethod) == null) {
QueryServiceGrpc.getExecuteQueryMethod = getExecuteQueryMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.SERVER_STREAMING)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ExecuteQuery"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.ExecuteQueryResponsePart.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("ExecuteQuery"))
.build();
}
}
}
return getExecuteQueryMethod;
}
private static volatile io.grpc.MethodDescriptor getExecuteScriptMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "ExecuteScript",
requestType = tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest.class,
responseType = tech.ydb.proto.OperationProtos.Operation.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getExecuteScriptMethod() {
io.grpc.MethodDescriptor getExecuteScriptMethod;
if ((getExecuteScriptMethod = QueryServiceGrpc.getExecuteScriptMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getExecuteScriptMethod = QueryServiceGrpc.getExecuteScriptMethod) == null) {
QueryServiceGrpc.getExecuteScriptMethod = getExecuteScriptMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "ExecuteScript"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.OperationProtos.Operation.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("ExecuteScript"))
.build();
}
}
}
return getExecuteScriptMethod;
}
private static volatile io.grpc.MethodDescriptor getFetchScriptResultsMethod;
@io.grpc.stub.annotations.RpcMethod(
fullMethodName = SERVICE_NAME + '/' + "FetchScriptResults",
requestType = tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest.class,
responseType = tech.ydb.proto.query.YdbQuery.FetchScriptResultsResponse.class,
methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
public static io.grpc.MethodDescriptor getFetchScriptResultsMethod() {
io.grpc.MethodDescriptor getFetchScriptResultsMethod;
if ((getFetchScriptResultsMethod = QueryServiceGrpc.getFetchScriptResultsMethod) == null) {
synchronized (QueryServiceGrpc.class) {
if ((getFetchScriptResultsMethod = QueryServiceGrpc.getFetchScriptResultsMethod) == null) {
QueryServiceGrpc.getFetchScriptResultsMethod = getFetchScriptResultsMethod =
io.grpc.MethodDescriptor.newBuilder()
.setType(io.grpc.MethodDescriptor.MethodType.UNARY)
.setFullMethodName(generateFullMethodName(SERVICE_NAME, "FetchScriptResults"))
.setSampledToLocalTracing(true)
.setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest.getDefaultInstance()))
.setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller(
tech.ydb.proto.query.YdbQuery.FetchScriptResultsResponse.getDefaultInstance()))
.setSchemaDescriptor(new QueryServiceMethodDescriptorSupplier("FetchScriptResults"))
.build();
}
}
}
return getFetchScriptResultsMethod;
}
/**
* Creates a new async stub that supports all call types for the service
*/
public static QueryServiceStub newStub(io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public QueryServiceStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceStub(channel, callOptions);
}
};
return QueryServiceStub.newStub(factory, channel);
}
/**
* Creates a new blocking-style stub that supports unary and streaming output calls on the service
*/
public static QueryServiceBlockingStub newBlockingStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public QueryServiceBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceBlockingStub(channel, callOptions);
}
};
return QueryServiceBlockingStub.newStub(factory, channel);
}
/**
* Creates a new ListenableFuture-style stub that supports unary calls on the service
*/
public static QueryServiceFutureStub newFutureStub(
io.grpc.Channel channel) {
io.grpc.stub.AbstractStub.StubFactory factory =
new io.grpc.stub.AbstractStub.StubFactory() {
@java.lang.Override
public QueryServiceFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceFutureStub(channel, callOptions);
}
};
return QueryServiceFutureStub.newStub(factory, channel);
}
/**
*/
public interface AsyncService {
/**
*
* 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.
*
*/
default void createSession(tech.ydb.proto.query.YdbQuery.CreateSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateSessionMethod(), responseObserver);
}
/**
*/
default void deleteSession(tech.ydb.proto.query.YdbQuery.DeleteSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteSessionMethod(), responseObserver);
}
/**
*/
default void attachSession(tech.ydb.proto.query.YdbQuery.AttachSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getAttachSessionMethod(), responseObserver);
}
/**
*
* 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.
*
*/
default void beginTransaction(tech.ydb.proto.query.YdbQuery.BeginTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getBeginTransactionMethod(), responseObserver);
}
/**
*/
default void commitTransaction(tech.ydb.proto.query.YdbQuery.CommitTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCommitTransactionMethod(), responseObserver);
}
/**
*/
default void rollbackTransaction(tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRollbackTransactionMethod(), responseObserver);
}
/**
*
* 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.
*
*/
default void executeQuery(tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExecuteQueryMethod(), responseObserver);
}
/**
*
* 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.
*
*/
default void executeScript(tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getExecuteScriptMethod(), responseObserver);
}
/**
*
* 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.
*
*/
default void fetchScriptResults(tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getFetchScriptResultsMethod(), responseObserver);
}
}
/**
* Base class for the server implementation of the service QueryService.
*/
public static abstract class QueryServiceImplBase
implements io.grpc.BindableService, AsyncService {
@java.lang.Override public final io.grpc.ServerServiceDefinition bindService() {
return QueryServiceGrpc.bindService(this);
}
}
/**
* A stub to allow clients to do asynchronous rpc calls to service QueryService.
*/
public static final class QueryServiceStub
extends io.grpc.stub.AbstractAsyncStub {
private QueryServiceStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected QueryServiceStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceStub(channel, callOptions);
}
/**
*
* 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.
*
*/
public void createSession(tech.ydb.proto.query.YdbQuery.CreateSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getCreateSessionMethod(), getCallOptions()), request, responseObserver);
}
/**
*/
public void deleteSession(tech.ydb.proto.query.YdbQuery.DeleteSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getDeleteSessionMethod(), getCallOptions()), request, responseObserver);
}
/**
*/
public void attachSession(tech.ydb.proto.query.YdbQuery.AttachSessionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncServerStreamingCall(
getChannel().newCall(getAttachSessionMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* 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.
*
*/
public void beginTransaction(tech.ydb.proto.query.YdbQuery.BeginTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getBeginTransactionMethod(), getCallOptions()), request, responseObserver);
}
/**
*/
public void commitTransaction(tech.ydb.proto.query.YdbQuery.CommitTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getCommitTransactionMethod(), getCallOptions()), request, responseObserver);
}
/**
*/
public void rollbackTransaction(tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getRollbackTransactionMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* 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.
*
*/
public void executeQuery(tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncServerStreamingCall(
getChannel().newCall(getExecuteQueryMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* 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.
*
*/
public void executeScript(tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getExecuteScriptMethod(), getCallOptions()), request, responseObserver);
}
/**
*
* 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.
*
*/
public void fetchScriptResults(tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest request,
io.grpc.stub.StreamObserver responseObserver) {
io.grpc.stub.ClientCalls.asyncUnaryCall(
getChannel().newCall(getFetchScriptResultsMethod(), getCallOptions()), request, responseObserver);
}
}
/**
* A stub to allow clients to do synchronous rpc calls to service QueryService.
*/
public static final class QueryServiceBlockingStub
extends io.grpc.stub.AbstractBlockingStub {
private QueryServiceBlockingStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected QueryServiceBlockingStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceBlockingStub(channel, callOptions);
}
/**
*
* 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.
*
*/
public tech.ydb.proto.query.YdbQuery.CreateSessionResponse createSession(tech.ydb.proto.query.YdbQuery.CreateSessionRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getCreateSessionMethod(), getCallOptions(), request);
}
/**
*/
public tech.ydb.proto.query.YdbQuery.DeleteSessionResponse deleteSession(tech.ydb.proto.query.YdbQuery.DeleteSessionRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getDeleteSessionMethod(), getCallOptions(), request);
}
/**
*/
public java.util.Iterator attachSession(
tech.ydb.proto.query.YdbQuery.AttachSessionRequest request) {
return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
getChannel(), getAttachSessionMethod(), getCallOptions(), request);
}
/**
*
* 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.
*
*/
public tech.ydb.proto.query.YdbQuery.BeginTransactionResponse beginTransaction(tech.ydb.proto.query.YdbQuery.BeginTransactionRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getBeginTransactionMethod(), getCallOptions(), request);
}
/**
*/
public tech.ydb.proto.query.YdbQuery.CommitTransactionResponse commitTransaction(tech.ydb.proto.query.YdbQuery.CommitTransactionRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getCommitTransactionMethod(), getCallOptions(), request);
}
/**
*/
public tech.ydb.proto.query.YdbQuery.RollbackTransactionResponse rollbackTransaction(tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getRollbackTransactionMethod(), getCallOptions(), request);
}
/**
*
* 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.
*
*/
public java.util.Iterator executeQuery(
tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest request) {
return io.grpc.stub.ClientCalls.blockingServerStreamingCall(
getChannel(), getExecuteQueryMethod(), getCallOptions(), request);
}
/**
*
* 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.
*
*/
public tech.ydb.proto.OperationProtos.Operation executeScript(tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getExecuteScriptMethod(), getCallOptions(), request);
}
/**
*
* 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.
*
*/
public tech.ydb.proto.query.YdbQuery.FetchScriptResultsResponse fetchScriptResults(tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest request) {
return io.grpc.stub.ClientCalls.blockingUnaryCall(
getChannel(), getFetchScriptResultsMethod(), getCallOptions(), request);
}
}
/**
* A stub to allow clients to do ListenableFuture-style rpc calls to service QueryService.
*/
public static final class QueryServiceFutureStub
extends io.grpc.stub.AbstractFutureStub {
private QueryServiceFutureStub(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
super(channel, callOptions);
}
@java.lang.Override
protected QueryServiceFutureStub build(
io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
return new QueryServiceFutureStub(channel, callOptions);
}
/**
*
* 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.
*
*/
public com.google.common.util.concurrent.ListenableFuture createSession(
tech.ydb.proto.query.YdbQuery.CreateSessionRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getCreateSessionMethod(), getCallOptions()), request);
}
/**
*/
public com.google.common.util.concurrent.ListenableFuture deleteSession(
tech.ydb.proto.query.YdbQuery.DeleteSessionRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getDeleteSessionMethod(), getCallOptions()), request);
}
/**
*
* 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.
*
*/
public com.google.common.util.concurrent.ListenableFuture beginTransaction(
tech.ydb.proto.query.YdbQuery.BeginTransactionRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getBeginTransactionMethod(), getCallOptions()), request);
}
/**
*/
public com.google.common.util.concurrent.ListenableFuture commitTransaction(
tech.ydb.proto.query.YdbQuery.CommitTransactionRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getCommitTransactionMethod(), getCallOptions()), request);
}
/**
*/
public com.google.common.util.concurrent.ListenableFuture rollbackTransaction(
tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getRollbackTransactionMethod(), getCallOptions()), request);
}
/**
*
* 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.
*
*/
public com.google.common.util.concurrent.ListenableFuture executeScript(
tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getExecuteScriptMethod(), getCallOptions()), request);
}
/**
*
* 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.
*
*/
public com.google.common.util.concurrent.ListenableFuture fetchScriptResults(
tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest request) {
return io.grpc.stub.ClientCalls.futureUnaryCall(
getChannel().newCall(getFetchScriptResultsMethod(), getCallOptions()), request);
}
}
private static final int METHODID_CREATE_SESSION = 0;
private static final int METHODID_DELETE_SESSION = 1;
private static final int METHODID_ATTACH_SESSION = 2;
private static final int METHODID_BEGIN_TRANSACTION = 3;
private static final int METHODID_COMMIT_TRANSACTION = 4;
private static final int METHODID_ROLLBACK_TRANSACTION = 5;
private static final int METHODID_EXECUTE_QUERY = 6;
private static final int METHODID_EXECUTE_SCRIPT = 7;
private static final int METHODID_FETCH_SCRIPT_RESULTS = 8;
private static final class MethodHandlers implements
io.grpc.stub.ServerCalls.UnaryMethod,
io.grpc.stub.ServerCalls.ServerStreamingMethod,
io.grpc.stub.ServerCalls.ClientStreamingMethod,
io.grpc.stub.ServerCalls.BidiStreamingMethod {
private final AsyncService serviceImpl;
private final int methodId;
MethodHandlers(AsyncService serviceImpl, int methodId) {
this.serviceImpl = serviceImpl;
this.methodId = methodId;
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public void invoke(Req request, io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
case METHODID_CREATE_SESSION:
serviceImpl.createSession((tech.ydb.proto.query.YdbQuery.CreateSessionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_DELETE_SESSION:
serviceImpl.deleteSession((tech.ydb.proto.query.YdbQuery.DeleteSessionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_ATTACH_SESSION:
serviceImpl.attachSession((tech.ydb.proto.query.YdbQuery.AttachSessionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_BEGIN_TRANSACTION:
serviceImpl.beginTransaction((tech.ydb.proto.query.YdbQuery.BeginTransactionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_COMMIT_TRANSACTION:
serviceImpl.commitTransaction((tech.ydb.proto.query.YdbQuery.CommitTransactionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_ROLLBACK_TRANSACTION:
serviceImpl.rollbackTransaction((tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_EXECUTE_QUERY:
serviceImpl.executeQuery((tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_EXECUTE_SCRIPT:
serviceImpl.executeScript((tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
case METHODID_FETCH_SCRIPT_RESULTS:
serviceImpl.fetchScriptResults((tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest) request,
(io.grpc.stub.StreamObserver) responseObserver);
break;
default:
throw new AssertionError();
}
}
@java.lang.Override
@java.lang.SuppressWarnings("unchecked")
public io.grpc.stub.StreamObserver invoke(
io.grpc.stub.StreamObserver responseObserver) {
switch (methodId) {
default:
throw new AssertionError();
}
}
}
public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
.addMethod(
getCreateSessionMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.CreateSessionRequest,
tech.ydb.proto.query.YdbQuery.CreateSessionResponse>(
service, METHODID_CREATE_SESSION)))
.addMethod(
getDeleteSessionMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.DeleteSessionRequest,
tech.ydb.proto.query.YdbQuery.DeleteSessionResponse>(
service, METHODID_DELETE_SESSION)))
.addMethod(
getAttachSessionMethod(),
io.grpc.stub.ServerCalls.asyncServerStreamingCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.AttachSessionRequest,
tech.ydb.proto.query.YdbQuery.SessionState>(
service, METHODID_ATTACH_SESSION)))
.addMethod(
getBeginTransactionMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.BeginTransactionRequest,
tech.ydb.proto.query.YdbQuery.BeginTransactionResponse>(
service, METHODID_BEGIN_TRANSACTION)))
.addMethod(
getCommitTransactionMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.CommitTransactionRequest,
tech.ydb.proto.query.YdbQuery.CommitTransactionResponse>(
service, METHODID_COMMIT_TRANSACTION)))
.addMethod(
getRollbackTransactionMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.RollbackTransactionRequest,
tech.ydb.proto.query.YdbQuery.RollbackTransactionResponse>(
service, METHODID_ROLLBACK_TRANSACTION)))
.addMethod(
getExecuteQueryMethod(),
io.grpc.stub.ServerCalls.asyncServerStreamingCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.ExecuteQueryRequest,
tech.ydb.proto.query.YdbQuery.ExecuteQueryResponsePart>(
service, METHODID_EXECUTE_QUERY)))
.addMethod(
getExecuteScriptMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.ExecuteScriptRequest,
tech.ydb.proto.OperationProtos.Operation>(
service, METHODID_EXECUTE_SCRIPT)))
.addMethod(
getFetchScriptResultsMethod(),
io.grpc.stub.ServerCalls.asyncUnaryCall(
new MethodHandlers<
tech.ydb.proto.query.YdbQuery.FetchScriptResultsRequest,
tech.ydb.proto.query.YdbQuery.FetchScriptResultsResponse>(
service, METHODID_FETCH_SCRIPT_RESULTS)))
.build();
}
private static abstract class QueryServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier {
QueryServiceBaseDescriptorSupplier() {}
@java.lang.Override
public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
return tech.ydb.proto.query.v1.YdbQueryV1.getDescriptor();
}
@java.lang.Override
public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
return getFileDescriptor().findServiceByName("QueryService");
}
}
private static final class QueryServiceFileDescriptorSupplier
extends QueryServiceBaseDescriptorSupplier {
QueryServiceFileDescriptorSupplier() {}
}
private static final class QueryServiceMethodDescriptorSupplier
extends QueryServiceBaseDescriptorSupplier
implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
private final java.lang.String methodName;
QueryServiceMethodDescriptorSupplier(java.lang.String methodName) {
this.methodName = methodName;
}
@java.lang.Override
public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
return getServiceDescriptor().findMethodByName(methodName);
}
}
private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
public static io.grpc.ServiceDescriptor getServiceDescriptor() {
io.grpc.ServiceDescriptor result = serviceDescriptor;
if (result == null) {
synchronized (QueryServiceGrpc.class) {
result = serviceDescriptor;
if (result == null) {
serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
.setSchemaDescriptor(new QueryServiceFileDescriptorSupplier())
.addMethod(getCreateSessionMethod())
.addMethod(getDeleteSessionMethod())
.addMethod(getAttachSessionMethod())
.addMethod(getBeginTransactionMethod())
.addMethod(getCommitTransactionMethod())
.addMethod(getRollbackTransactionMethod())
.addMethod(getExecuteQueryMethod())
.addMethod(getExecuteScriptMethod())
.addMethod(getFetchScriptResultsMethod())
.build();
}
}
}
return result;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy