// Copyright 2025 Google LLC // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. // Code generated by protoc-gen-go-grpc. DO NOT EDIT. // versions: // - protoc-gen-go-grpc v1.3.0 // - protoc v4.25.7 // source: google/bigtable/v2/bigtable.proto package bigtablepb import ( context "context" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" ) // 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 const ( Bigtable_ReadRows_FullMethodName = "/google.bigtable.v2.Bigtable/ReadRows" Bigtable_SampleRowKeys_FullMethodName = "/google.bigtable.v2.Bigtable/SampleRowKeys" Bigtable_MutateRow_FullMethodName = "/google.bigtable.v2.Bigtable/MutateRow" Bigtable_MutateRows_FullMethodName = "/google.bigtable.v2.Bigtable/MutateRows" Bigtable_CheckAndMutateRow_FullMethodName = "/google.bigtable.v2.Bigtable/CheckAndMutateRow" Bigtable_PingAndWarm_FullMethodName = "/google.bigtable.v2.Bigtable/PingAndWarm" Bigtable_ReadModifyWriteRow_FullMethodName = "/google.bigtable.v2.Bigtable/ReadModifyWriteRow" Bigtable_GenerateInitialChangeStreamPartitions_FullMethodName = "/google.bigtable.v2.Bigtable/GenerateInitialChangeStreamPartitions" Bigtable_ReadChangeStream_FullMethodName = "/google.bigtable.v2.Bigtable/ReadChangeStream" Bigtable_PrepareQuery_FullMethodName = "/google.bigtable.v2.Bigtable/PrepareQuery" Bigtable_ExecuteQuery_FullMethodName = "/google.bigtable.v2.Bigtable/ExecuteQuery" ) // BigtableClient is the client API for Bigtable 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 BigtableClient interface { // Streams back the contents of all requested rows in key order, optionally // applying the same Reader filter to each. Depending on their size, // rows and cells may be broken up across multiple responses, but // atomicity of each row will still be preserved. See the // ReadRowsResponse documentation for details. ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error) // Returns a sample of row keys in the table. The returned row keys will // delimit contiguous sections of the table of approximately equal size, // which can be used to break up the data for distributed tasks like // mapreduces. SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error) // Mutates a row atomically. Cells already present in the row are left // unchanged unless explicitly changed by `mutation`. MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error) // Mutates multiple rows in a batch. Each individual row is mutated // atomically as in MutateRow, but the entire batch is not executed // atomically. MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error) // Mutates a row atomically based on the output of a predicate Reader filter. CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) // Warm up associated instance metadata for this connection. // This call is not required but may be useful for connection keep-alive. PingAndWarm(ctx context.Context, in *PingAndWarmRequest, opts ...grpc.CallOption) (*PingAndWarmResponse, error) // Modifies a row atomically on the server. The method reads the latest // existing timestamp and value from the specified columns and writes a new // entry based on pre-defined read/modify/write rules. The new value for the // timestamp is the greater of the existing timestamp or the current server // time. The method returns the new contents of all modified cells. ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error) // Returns the current list of partitions that make up the table's // change stream. The union of partitions will cover the entire keyspace. // Partitions can be read with `ReadChangeStream`. // NOTE: This API is only intended to be used by Apache Beam BigtableIO. GenerateInitialChangeStreamPartitions(ctx context.Context, in *GenerateInitialChangeStreamPartitionsRequest, opts ...grpc.CallOption) (Bigtable_GenerateInitialChangeStreamPartitionsClient, error) // Reads changes from a table's change stream. Changes will // reflect both user-initiated mutations and mutations that are caused by // garbage collection. // NOTE: This API is only intended to be used by Apache Beam BigtableIO. ReadChangeStream(ctx context.Context, in *ReadChangeStreamRequest, opts ...grpc.CallOption) (Bigtable_ReadChangeStreamClient, error) // Prepares a GoogleSQL query for execution on a particular Bigtable instance. PrepareQuery(ctx context.Context, in *PrepareQueryRequest, opts ...grpc.CallOption) (*PrepareQueryResponse, error) // Executes a SQL query against a particular Bigtable instance. ExecuteQuery(ctx context.Context, in *ExecuteQueryRequest, opts ...grpc.CallOption) (Bigtable_ExecuteQueryClient, error) } type bigtableClient struct { cc grpc.ClientConnInterface } func NewBigtableClient(cc grpc.ClientConnInterface) BigtableClient { return &bigtableClient{cc} } func (c *bigtableClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[0], Bigtable_ReadRows_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableReadRowsClient{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 Bigtable_ReadRowsClient interface { Recv() (*ReadRowsResponse, error) grpc.ClientStream } type bigtableReadRowsClient struct { grpc.ClientStream } func (x *bigtableReadRowsClient) Recv() (*ReadRowsResponse, error) { m := new(ReadRowsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *bigtableClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[1], Bigtable_SampleRowKeys_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableSampleRowKeysClient{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 Bigtable_SampleRowKeysClient interface { Recv() (*SampleRowKeysResponse, error) grpc.ClientStream } type bigtableSampleRowKeysClient struct { grpc.ClientStream } func (x *bigtableSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) { m := new(SampleRowKeysResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *bigtableClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error) { out := new(MutateRowResponse) err := c.cc.Invoke(ctx, Bigtable_MutateRow_FullMethodName, in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *bigtableClient) MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[2], Bigtable_MutateRows_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableMutateRowsClient{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 Bigtable_MutateRowsClient interface { Recv() (*MutateRowsResponse, error) grpc.ClientStream } type bigtableMutateRowsClient struct { grpc.ClientStream } func (x *bigtableMutateRowsClient) Recv() (*MutateRowsResponse, error) { m := new(MutateRowsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *bigtableClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) { out := new(CheckAndMutateRowResponse) err := c.cc.Invoke(ctx, Bigtable_CheckAndMutateRow_FullMethodName, in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *bigtableClient) PingAndWarm(ctx context.Context, in *PingAndWarmRequest, opts ...grpc.CallOption) (*PingAndWarmResponse, error) { out := new(PingAndWarmResponse) err := c.cc.Invoke(ctx, Bigtable_PingAndWarm_FullMethodName, in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *bigtableClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error) { out := new(ReadModifyWriteRowResponse) err := c.cc.Invoke(ctx, Bigtable_ReadModifyWriteRow_FullMethodName, in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *bigtableClient) GenerateInitialChangeStreamPartitions(ctx context.Context, in *GenerateInitialChangeStreamPartitionsRequest, opts ...grpc.CallOption) (Bigtable_GenerateInitialChangeStreamPartitionsClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[3], Bigtable_GenerateInitialChangeStreamPartitions_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableGenerateInitialChangeStreamPartitionsClient{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 Bigtable_GenerateInitialChangeStreamPartitionsClient interface { Recv() (*GenerateInitialChangeStreamPartitionsResponse, error) grpc.ClientStream } type bigtableGenerateInitialChangeStreamPartitionsClient struct { grpc.ClientStream } func (x *bigtableGenerateInitialChangeStreamPartitionsClient) Recv() (*GenerateInitialChangeStreamPartitionsResponse, error) { m := new(GenerateInitialChangeStreamPartitionsResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *bigtableClient) ReadChangeStream(ctx context.Context, in *ReadChangeStreamRequest, opts ...grpc.CallOption) (Bigtable_ReadChangeStreamClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[4], Bigtable_ReadChangeStream_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableReadChangeStreamClient{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 Bigtable_ReadChangeStreamClient interface { Recv() (*ReadChangeStreamResponse, error) grpc.ClientStream } type bigtableReadChangeStreamClient struct { grpc.ClientStream } func (x *bigtableReadChangeStreamClient) Recv() (*ReadChangeStreamResponse, error) { m := new(ReadChangeStreamResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *bigtableClient) PrepareQuery(ctx context.Context, in *PrepareQueryRequest, opts ...grpc.CallOption) (*PrepareQueryResponse, error) { out := new(PrepareQueryResponse) err := c.cc.Invoke(ctx, Bigtable_PrepareQuery_FullMethodName, in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *bigtableClient) ExecuteQuery(ctx context.Context, in *ExecuteQueryRequest, opts ...grpc.CallOption) (Bigtable_ExecuteQueryClient, error) { stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[5], Bigtable_ExecuteQuery_FullMethodName, opts...) if err != nil { return nil, err } x := &bigtableExecuteQueryClient{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 Bigtable_ExecuteQueryClient interface { Recv() (*ExecuteQueryResponse, error) grpc.ClientStream } type bigtableExecuteQueryClient struct { grpc.ClientStream } func (x *bigtableExecuteQueryClient) Recv() (*ExecuteQueryResponse, error) { m := new(ExecuteQueryResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } // BigtableServer is the server API for Bigtable service. // All implementations should embed UnimplementedBigtableServer // for forward compatibility type BigtableServer interface { // Streams back the contents of all requested rows in key order, optionally // applying the same Reader filter to each. Depending on their size, // rows and cells may be broken up across multiple responses, but // atomicity of each row will still be preserved. See the // ReadRowsResponse documentation for details. ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error // Returns a sample of row keys in the table. The returned row keys will // delimit contiguous sections of the table of approximately equal size, // which can be used to break up the data for distributed tasks like // mapreduces. SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error // Mutates a row atomically. Cells already present in the row are left // unchanged unless explicitly changed by `mutation`. MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error) // Mutates multiple rows in a batch. Each individual row is mutated // atomically as in MutateRow, but the entire batch is not executed // atomically. MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error // Mutates a row atomically based on the output of a predicate Reader filter. CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error) // Warm up associated instance metadata for this connection. // This call is not required but may be useful for connection keep-alive. PingAndWarm(context.Context, *PingAndWarmRequest) (*PingAndWarmResponse, error) // Modifies a row atomically on the server. The method reads the latest // existing timestamp and value from the specified columns and writes a new // entry based on pre-defined read/modify/write rules. The new value for the // timestamp is the greater of the existing timestamp or the current server // time. The method returns the new contents of all modified cells. ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error) // Returns the current list of partitions that make up the table's // change stream. The union of partitions will cover the entire keyspace. // Partitions can be read with `ReadChangeStream`. // NOTE: This API is only intended to be used by Apache Beam BigtableIO. GenerateInitialChangeStreamPartitions(*GenerateInitialChangeStreamPartitionsRequest, Bigtable_GenerateInitialChangeStreamPartitionsServer) error // Reads changes from a table's change stream. Changes will // reflect both user-initiated mutations and mutations that are caused by // garbage collection. // NOTE: This API is only intended to be used by Apache Beam BigtableIO. ReadChangeStream(*ReadChangeStreamRequest, Bigtable_ReadChangeStreamServer) error // Prepares a GoogleSQL query for execution on a particular Bigtable instance. PrepareQuery(context.Context, *PrepareQueryRequest) (*PrepareQueryResponse, error) // Executes a SQL query against a particular Bigtable instance. ExecuteQuery(*ExecuteQueryRequest, Bigtable_ExecuteQueryServer) error } // UnimplementedBigtableServer should be embedded to have forward compatible implementations. type UnimplementedBigtableServer struct { } func (UnimplementedBigtableServer) ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error { return status.Errorf(codes.Unimplemented, "method ReadRows not implemented") } func (UnimplementedBigtableServer) SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error { return status.Errorf(codes.Unimplemented, "method SampleRowKeys not implemented") } func (UnimplementedBigtableServer) MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method MutateRow not implemented") } func (UnimplementedBigtableServer) MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error { return status.Errorf(codes.Unimplemented, "method MutateRows not implemented") } func (UnimplementedBigtableServer) CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CheckAndMutateRow not implemented") } func (UnimplementedBigtableServer) PingAndWarm(context.Context, *PingAndWarmRequest) (*PingAndWarmResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PingAndWarm not implemented") } func (UnimplementedBigtableServer) ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ReadModifyWriteRow not implemented") } func (UnimplementedBigtableServer) GenerateInitialChangeStreamPartitions(*GenerateInitialChangeStreamPartitionsRequest, Bigtable_GenerateInitialChangeStreamPartitionsServer) error { return status.Errorf(codes.Unimplemented, "method GenerateInitialChangeStreamPartitions not implemented") } func (UnimplementedBigtableServer) ReadChangeStream(*ReadChangeStreamRequest, Bigtable_ReadChangeStreamServer) error { return status.Errorf(codes.Unimplemented, "method ReadChangeStream not implemented") } func (UnimplementedBigtableServer) PrepareQuery(context.Context, *PrepareQueryRequest) (*PrepareQueryResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PrepareQuery not implemented") } func (UnimplementedBigtableServer) ExecuteQuery(*ExecuteQueryRequest, Bigtable_ExecuteQueryServer) error { return status.Errorf(codes.Unimplemented, "method ExecuteQuery not implemented") } // UnsafeBigtableServer may be embedded to opt out of forward compatibility for this service. // Use of this interface is not recommended, as added methods to BigtableServer will // result in compilation errors. type UnsafeBigtableServer interface { mustEmbedUnimplementedBigtableServer() } func RegisterBigtableServer(s grpc.ServiceRegistrar, srv BigtableServer) { s.RegisterService(&Bigtable_ServiceDesc, srv) } func _Bigtable_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ReadRowsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).ReadRows(m, &bigtableReadRowsServer{stream}) } type Bigtable_ReadRowsServer interface { Send(*ReadRowsResponse) error grpc.ServerStream } type bigtableReadRowsServer struct { grpc.ServerStream } func (x *bigtableReadRowsServer) Send(m *ReadRowsResponse) error { return x.ServerStream.SendMsg(m) } func _Bigtable_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(SampleRowKeysRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).SampleRowKeys(m, &bigtableSampleRowKeysServer{stream}) } type Bigtable_SampleRowKeysServer interface { Send(*SampleRowKeysResponse) error grpc.ServerStream } type bigtableSampleRowKeysServer struct { grpc.ServerStream } func (x *bigtableSampleRowKeysServer) Send(m *SampleRowKeysResponse) error { return x.ServerStream.SendMsg(m) } func _Bigtable_MutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(MutateRowRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(BigtableServer).MutateRow(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: Bigtable_MutateRow_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BigtableServer).MutateRow(ctx, req.(*MutateRowRequest)) } return interceptor(ctx, in, info, handler) } func _Bigtable_MutateRows_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(MutateRowsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).MutateRows(m, &bigtableMutateRowsServer{stream}) } type Bigtable_MutateRowsServer interface { Send(*MutateRowsResponse) error grpc.ServerStream } type bigtableMutateRowsServer struct { grpc.ServerStream } func (x *bigtableMutateRowsServer) Send(m *MutateRowsResponse) error { return x.ServerStream.SendMsg(m) } func _Bigtable_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CheckAndMutateRowRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(BigtableServer).CheckAndMutateRow(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: Bigtable_CheckAndMutateRow_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BigtableServer).CheckAndMutateRow(ctx, req.(*CheckAndMutateRowRequest)) } return interceptor(ctx, in, info, handler) } func _Bigtable_PingAndWarm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PingAndWarmRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(BigtableServer).PingAndWarm(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: Bigtable_PingAndWarm_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BigtableServer).PingAndWarm(ctx, req.(*PingAndWarmRequest)) } return interceptor(ctx, in, info, handler) } func _Bigtable_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ReadModifyWriteRowRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(BigtableServer).ReadModifyWriteRow(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: Bigtable_ReadModifyWriteRow_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BigtableServer).ReadModifyWriteRow(ctx, req.(*ReadModifyWriteRowRequest)) } return interceptor(ctx, in, info, handler) } func _Bigtable_GenerateInitialChangeStreamPartitions_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(GenerateInitialChangeStreamPartitionsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).GenerateInitialChangeStreamPartitions(m, &bigtableGenerateInitialChangeStreamPartitionsServer{stream}) } type Bigtable_GenerateInitialChangeStreamPartitionsServer interface { Send(*GenerateInitialChangeStreamPartitionsResponse) error grpc.ServerStream } type bigtableGenerateInitialChangeStreamPartitionsServer struct { grpc.ServerStream } func (x *bigtableGenerateInitialChangeStreamPartitionsServer) Send(m *GenerateInitialChangeStreamPartitionsResponse) error { return x.ServerStream.SendMsg(m) } func _Bigtable_ReadChangeStream_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ReadChangeStreamRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).ReadChangeStream(m, &bigtableReadChangeStreamServer{stream}) } type Bigtable_ReadChangeStreamServer interface { Send(*ReadChangeStreamResponse) error grpc.ServerStream } type bigtableReadChangeStreamServer struct { grpc.ServerStream } func (x *bigtableReadChangeStreamServer) Send(m *ReadChangeStreamResponse) error { return x.ServerStream.SendMsg(m) } func _Bigtable_PrepareQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PrepareQueryRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(BigtableServer).PrepareQuery(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: Bigtable_PrepareQuery_FullMethodName, } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(BigtableServer).PrepareQuery(ctx, req.(*PrepareQueryRequest)) } return interceptor(ctx, in, info, handler) } func _Bigtable_ExecuteQuery_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(ExecuteQueryRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(BigtableServer).ExecuteQuery(m, &bigtableExecuteQueryServer{stream}) } type Bigtable_ExecuteQueryServer interface { Send(*ExecuteQueryResponse) error grpc.ServerStream } type bigtableExecuteQueryServer struct { grpc.ServerStream } func (x *bigtableExecuteQueryServer) Send(m *ExecuteQueryResponse) error { return x.ServerStream.SendMsg(m) } // Bigtable_ServiceDesc is the grpc.ServiceDesc for Bigtable service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) var Bigtable_ServiceDesc = grpc.ServiceDesc{ ServiceName: "google.bigtable.v2.Bigtable", HandlerType: (*BigtableServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "MutateRow", Handler: _Bigtable_MutateRow_Handler, }, { MethodName: "CheckAndMutateRow", Handler: _Bigtable_CheckAndMutateRow_Handler, }, { MethodName: "PingAndWarm", Handler: _Bigtable_PingAndWarm_Handler, }, { MethodName: "ReadModifyWriteRow", Handler: _Bigtable_ReadModifyWriteRow_Handler, }, { MethodName: "PrepareQuery", Handler: _Bigtable_PrepareQuery_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "ReadRows", Handler: _Bigtable_ReadRows_Handler, ServerStreams: true, }, { StreamName: "SampleRowKeys", Handler: _Bigtable_SampleRowKeys_Handler, ServerStreams: true, }, { StreamName: "MutateRows", Handler: _Bigtable_MutateRows_Handler, ServerStreams: true, }, { StreamName: "GenerateInitialChangeStreamPartitions", Handler: _Bigtable_GenerateInitialChangeStreamPartitions_Handler, ServerStreams: true, }, { StreamName: "ReadChangeStream", Handler: _Bigtable_ReadChangeStream_Handler, ServerStreams: true, }, { StreamName: "ExecuteQuery", Handler: _Bigtable_ExecuteQuery_Handler, ServerStreams: true, }, }, Metadata: "google/bigtable/v2/bigtable.proto", }