Trait kvproto::tikvpb::Tikv[−][src]

pub trait Tikv {
    fn kv_get(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetRequest, 
        sink: UnarySink<GetResponse>
    );

    fn kv_scan(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ScanRequest, 
        sink: UnarySink<ScanResponse>
    );

    fn kv_prewrite(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PrewriteRequest, 
        sink: UnarySink<PrewriteResponse>
    );

    fn kv_pessimistic_lock(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PessimisticLockRequest, 
        sink: UnarySink<PessimisticLockResponse>
    );

    fn kv_pessimistic_rollback(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PessimisticRollbackRequest, 
        sink: UnarySink<PessimisticRollbackResponse>
    );

    fn kv_txn_heart_beat(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: TxnHeartBeatRequest, 
        sink: UnarySink<TxnHeartBeatResponse>
    );

    fn kv_check_txn_status(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CheckTxnStatusRequest, 
        sink: UnarySink<CheckTxnStatusResponse>
    );

    fn kv_check_secondary_locks(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CheckSecondaryLocksRequest, 
        sink: UnarySink<CheckSecondaryLocksResponse>
    );

    fn kv_commit(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CommitRequest, 
        sink: UnarySink<CommitResponse>
    );

    fn kv_import(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ImportRequest, 
        sink: UnarySink<ImportResponse>
    );

    fn kv_cleanup(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CleanupRequest, 
        sink: UnarySink<CleanupResponse>
    );

    fn kv_batch_get(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: BatchGetRequest, 
        sink: UnarySink<BatchGetResponse>
    );

    fn kv_batch_rollback(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: BatchRollbackRequest, 
        sink: UnarySink<BatchRollbackResponse>
    );

    fn kv_scan_lock(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ScanLockRequest, 
        sink: UnarySink<ScanLockResponse>
    );

    fn kv_resolve_lock(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ResolveLockRequest, 
        sink: UnarySink<ResolveLockResponse>
    );

    fn kv_gc(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GcRequest, 
        sink: UnarySink<GcResponse>
    );

    fn kv_delete_range(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DeleteRangeRequest, 
        sink: UnarySink<DeleteRangeResponse>
    );

    fn raw_get(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawGetRequest, 
        sink: UnarySink<RawGetResponse>
    );

    fn raw_batch_get(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawBatchGetRequest, 
        sink: UnarySink<RawBatchGetResponse>
    );

    fn raw_put(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawPutRequest, 
        sink: UnarySink<RawPutResponse>
    );

    fn raw_batch_put(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawBatchPutRequest, 
        sink: UnarySink<RawBatchPutResponse>
    );

    fn raw_delete(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawDeleteRequest, 
        sink: UnarySink<RawDeleteResponse>
    );

    fn raw_batch_delete(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawBatchDeleteRequest, 
        sink: UnarySink<RawBatchDeleteResponse>
    );

    fn raw_scan(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawScanRequest, 
        sink: UnarySink<RawScanResponse>
    );

    fn raw_delete_range(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawDeleteRangeRequest, 
        sink: UnarySink<RawDeleteRangeResponse>
    );

    fn raw_batch_scan(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawBatchScanRequest, 
        sink: UnarySink<RawBatchScanResponse>
    );

    fn raw_get_key_ttl(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawGetKeyTtlRequest, 
        sink: UnarySink<RawGetKeyTtlResponse>
    );

    fn raw_compare_and_swap(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawCasRequest, 
        sink: UnarySink<RawCasResponse>
    );

    fn unsafe_destroy_range(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: UnsafeDestroyRangeRequest, 
        sink: UnarySink<UnsafeDestroyRangeResponse>
    );

    fn register_lock_observer(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RegisterLockObserverRequest, 
        sink: UnarySink<RegisterLockObserverResponse>
    );

    fn check_lock_observer(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CheckLockObserverRequest, 
        sink: UnarySink<CheckLockObserverResponse>
    );

    fn remove_lock_observer(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RemoveLockObserverRequest, 
        sink: UnarySink<RemoveLockObserverResponse>
    );

    fn physical_scan_lock(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: PhysicalScanLockRequest, 
        sink: UnarySink<PhysicalScanLockResponse>
    );

    fn coprocessor(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: Request, 
        sink: UnarySink<Response>
    );

    fn coprocessor_stream(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: Request, 
        sink: ServerStreamingSink<Response>
    );

    fn batch_coprocessor(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: BatchRequest, 
        sink: ServerStreamingSink<BatchResponse>
    );

    fn raw_coprocessor(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: RawCoprocessorRequest, 
        sink: UnarySink<RawCoprocessorResponse>
    );

    fn raft(
        &mut self, 
        ctx: RpcContext<'_>, 
        stream: RequestStream<RaftMessage>, 
        sink: ClientStreamingSink<Done>
    );

    fn batch_raft(
        &mut self, 
        ctx: RpcContext<'_>, 
        stream: RequestStream<BatchRaftMessage>, 
        sink: ClientStreamingSink<Done>
    );

    fn snapshot(
        &mut self, 
        ctx: RpcContext<'_>, 
        stream: RequestStream<SnapshotChunk>, 
        sink: ClientStreamingSink<Done>
    );

    fn split_region(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: SplitRegionRequest, 
        sink: UnarySink<SplitRegionResponse>
    );

    fn read_index(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: ReadIndexRequest, 
        sink: UnarySink<ReadIndexResponse>
    );

    fn mvcc_get_by_key(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: MvccGetByKeyRequest, 
        sink: UnarySink<MvccGetByKeyResponse>
    );

    fn mvcc_get_by_start_ts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: MvccGetByStartTsRequest, 
        sink: UnarySink<MvccGetByStartTsResponse>
    );

    fn batch_commands(
        &mut self, 
        ctx: RpcContext<'_>, 
        stream: RequestStream<BatchCommandsRequest>, 
        sink: DuplexSink<BatchCommandsResponse>
    );

    fn dispatch_mpp_task(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: DispatchTaskRequest, 
        sink: UnarySink<DispatchTaskResponse>
    );

    fn cancel_mpp_task(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CancelTaskRequest, 
        sink: UnarySink<CancelTaskResponse>
    );

    fn establish_mpp_connection(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: EstablishMppConnectionRequest, 
        sink: ServerStreamingSink<MppDataPacket>
    );

    fn check_leader(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: CheckLeaderRequest, 
        sink: UnarySink<CheckLeaderResponse>
    );

    fn get_store_safe_ts(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: StoreSafeTsRequest, 
        sink: UnarySink<StoreSafeTsResponse>
    );

    fn get_lock_wait_info(
        &mut self, 
        ctx: RpcContext<'_>, 
        req: GetLockWaitInfoRequest, 
        sink: UnarySink<GetLockWaitInfoResponse>
    );
}

Required methods

fn kv_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: GetRequest,
    sink: UnarySink<GetResponse>
)[src]

fn kv_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: ScanRequest,
    sink: UnarySink<ScanResponse>
)[src]

fn kv_prewrite(
    &mut self,
    ctx: RpcContext<'_>,
    req: PrewriteRequest,
    sink: UnarySink<PrewriteResponse>
)[src]

fn kv_pessimistic_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: PessimisticLockRequest,
    sink: UnarySink<PessimisticLockResponse>
)[src]

fn kv_pessimistic_rollback(
    &mut self,
    ctx: RpcContext<'_>,
    req: PessimisticRollbackRequest,
    sink: UnarySink<PessimisticRollbackResponse>
)[src]

fn kv_txn_heart_beat(
    &mut self,
    ctx: RpcContext<'_>,
    req: TxnHeartBeatRequest,
    sink: UnarySink<TxnHeartBeatResponse>
)[src]

fn kv_check_txn_status(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckTxnStatusRequest,
    sink: UnarySink<CheckTxnStatusResponse>
)[src]

fn kv_check_secondary_locks(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckSecondaryLocksRequest,
    sink: UnarySink<CheckSecondaryLocksResponse>
)[src]

fn kv_commit(
    &mut self,
    ctx: RpcContext<'_>,
    req: CommitRequest,
    sink: UnarySink<CommitResponse>
)[src]

fn kv_import(
    &mut self,
    ctx: RpcContext<'_>,
    req: ImportRequest,
    sink: UnarySink<ImportResponse>
)[src]

fn kv_cleanup(
    &mut self,
    ctx: RpcContext<'_>,
    req: CleanupRequest,
    sink: UnarySink<CleanupResponse>
)[src]

fn kv_batch_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: BatchGetRequest,
    sink: UnarySink<BatchGetResponse>
)[src]

fn kv_batch_rollback(
    &mut self,
    ctx: RpcContext<'_>,
    req: BatchRollbackRequest,
    sink: UnarySink<BatchRollbackResponse>
)[src]

fn kv_scan_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: ScanLockRequest,
    sink: UnarySink<ScanLockResponse>
)[src]

fn kv_resolve_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: ResolveLockRequest,
    sink: UnarySink<ResolveLockResponse>
)[src]

fn kv_gc(
    &mut self,
    ctx: RpcContext<'_>,
    req: GcRequest,
    sink: UnarySink<GcResponse>
)[src]

fn kv_delete_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: DeleteRangeRequest,
    sink: UnarySink<DeleteRangeResponse>
)[src]

fn raw_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawGetRequest,
    sink: UnarySink<RawGetResponse>
)[src]

fn raw_batch_get(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchGetRequest,
    sink: UnarySink<RawBatchGetResponse>
)[src]

fn raw_put(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawPutRequest,
    sink: UnarySink<RawPutResponse>
)[src]

fn raw_batch_put(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchPutRequest,
    sink: UnarySink<RawBatchPutResponse>
)[src]

fn raw_delete(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawDeleteRequest,
    sink: UnarySink<RawDeleteResponse>
)[src]

fn raw_batch_delete(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchDeleteRequest,
    sink: UnarySink<RawBatchDeleteResponse>
)[src]

fn raw_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawScanRequest,
    sink: UnarySink<RawScanResponse>
)[src]

fn raw_delete_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawDeleteRangeRequest,
    sink: UnarySink<RawDeleteRangeResponse>
)[src]

fn raw_batch_scan(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawBatchScanRequest,
    sink: UnarySink<RawBatchScanResponse>
)[src]

fn raw_get_key_ttl(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawGetKeyTtlRequest,
    sink: UnarySink<RawGetKeyTtlResponse>
)[src]

fn raw_compare_and_swap(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawCasRequest,
    sink: UnarySink<RawCasResponse>
)[src]

fn unsafe_destroy_range(
    &mut self,
    ctx: RpcContext<'_>,
    req: UnsafeDestroyRangeRequest,
    sink: UnarySink<UnsafeDestroyRangeResponse>
)[src]

fn register_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: RegisterLockObserverRequest,
    sink: UnarySink<RegisterLockObserverResponse>
)[src]

fn check_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckLockObserverRequest,
    sink: UnarySink<CheckLockObserverResponse>
)[src]

fn remove_lock_observer(
    &mut self,
    ctx: RpcContext<'_>,
    req: RemoveLockObserverRequest,
    sink: UnarySink<RemoveLockObserverResponse>
)[src]

fn physical_scan_lock(
    &mut self,
    ctx: RpcContext<'_>,
    req: PhysicalScanLockRequest,
    sink: UnarySink<PhysicalScanLockResponse>
)[src]

fn coprocessor(
    &mut self,
    ctx: RpcContext<'_>,
    req: Request,
    sink: UnarySink<Response>
)[src]

fn coprocessor_stream(
    &mut self,
    ctx: RpcContext<'_>,
    req: Request,
    sink: ServerStreamingSink<Response>
)[src]

fn batch_coprocessor(
    &mut self,
    ctx: RpcContext<'_>,
    req: BatchRequest,
    sink: ServerStreamingSink<BatchResponse>
)[src]

fn raw_coprocessor(
    &mut self,
    ctx: RpcContext<'_>,
    req: RawCoprocessorRequest,
    sink: UnarySink<RawCoprocessorResponse>
)[src]

fn raft(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<RaftMessage>,
    sink: ClientStreamingSink<Done>
)[src]

fn batch_raft(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<BatchRaftMessage>,
    sink: ClientStreamingSink<Done>
)[src]

fn snapshot(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<SnapshotChunk>,
    sink: ClientStreamingSink<Done>
)[src]

fn split_region(
    &mut self,
    ctx: RpcContext<'_>,
    req: SplitRegionRequest,
    sink: UnarySink<SplitRegionResponse>
)[src]

fn read_index(
    &mut self,
    ctx: RpcContext<'_>,
    req: ReadIndexRequest,
    sink: UnarySink<ReadIndexResponse>
)[src]

fn mvcc_get_by_key(
    &mut self,
    ctx: RpcContext<'_>,
    req: MvccGetByKeyRequest,
    sink: UnarySink<MvccGetByKeyResponse>
)[src]

fn mvcc_get_by_start_ts(
    &mut self,
    ctx: RpcContext<'_>,
    req: MvccGetByStartTsRequest,
    sink: UnarySink<MvccGetByStartTsResponse>
)[src]

fn batch_commands(
    &mut self,
    ctx: RpcContext<'_>,
    stream: RequestStream<BatchCommandsRequest>,
    sink: DuplexSink<BatchCommandsResponse>
)[src]

fn dispatch_mpp_task(
    &mut self,
    ctx: RpcContext<'_>,
    req: DispatchTaskRequest,
    sink: UnarySink<DispatchTaskResponse>
)[src]

fn cancel_mpp_task(
    &mut self,
    ctx: RpcContext<'_>,
    req: CancelTaskRequest,
    sink: UnarySink<CancelTaskResponse>
)[src]

fn establish_mpp_connection(
    &mut self,
    ctx: RpcContext<'_>,
    req: EstablishMppConnectionRequest,
    sink: ServerStreamingSink<MppDataPacket>
)[src]

fn check_leader(
    &mut self,
    ctx: RpcContext<'_>,
    req: CheckLeaderRequest,
    sink: UnarySink<CheckLeaderResponse>
)[src]

fn get_store_safe_ts(
    &mut self,
    ctx: RpcContext<'_>,
    req: StoreSafeTsRequest,
    sink: UnarySink<StoreSafeTsResponse>
)[src]

fn get_lock_wait_info(
    &mut self,
    ctx: RpcContext<'_>,
    req: GetLockWaitInfoRequest,
    sink: UnarySink<GetLockWaitInfoResponse>
)[src]

Loading content...

Implementors

Loading content...