Debian Codegraph @

bigtable/apiv2/bigtablepb/bigtable_grpc.pb.go

raw
1 // Copyright 2025 Google LLC
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 // Code generated by protoc-gen-go-grpc. DO NOT EDIT.
16 // versions:
17 // - protoc-gen-go-grpc v1.3.0
18 // - protoc v4.25.7
19 // source: google/bigtable/v2/bigtable.proto
20
21 package bigtablepb
22
23 import (
24 context "context"
25 grpc "google.golang.org/grpc"
26 codes "google.golang.org/grpc/codes"
27 status "google.golang.org/grpc/status"
28 )
29
30 // This is a compile-time assertion to ensure that this generated file
31 // is compatible with the grpc package it is being compiled against.
32 // Requires gRPC-Go v1.32.0 or later.
33 const _ = grpc.SupportPackageIsVersion7
34
35 const (
36 Bigtable_ReadRows_FullMethodName = "/google.bigtable.v2.Bigtable/ReadRows"
37 Bigtable_SampleRowKeys_FullMethodName = "/google.bigtable.v2.Bigtable/SampleRowKeys"
38 Bigtable_MutateRow_FullMethodName = "/google.bigtable.v2.Bigtable/MutateRow"
39 Bigtable_MutateRows_FullMethodName = "/google.bigtable.v2.Bigtable/MutateRows"
40 Bigtable_CheckAndMutateRow_FullMethodName = "/google.bigtable.v2.Bigtable/CheckAndMutateRow"
41 Bigtable_PingAndWarm_FullMethodName = "/google.bigtable.v2.Bigtable/PingAndWarm"
42 Bigtable_ReadModifyWriteRow_FullMethodName = "/google.bigtable.v2.Bigtable/ReadModifyWriteRow"
43 Bigtable_GenerateInitialChangeStreamPartitions_FullMethodName = "/google.bigtable.v2.Bigtable/GenerateInitialChangeStreamPartitions"
44 Bigtable_ReadChangeStream_FullMethodName = "/google.bigtable.v2.Bigtable/ReadChangeStream"
45 Bigtable_PrepareQuery_FullMethodName = "/google.bigtable.v2.Bigtable/PrepareQuery"
46 Bigtable_ExecuteQuery_FullMethodName = "/google.bigtable.v2.Bigtable/ExecuteQuery"
47 )
48
49 // BigtableClient is the client API for Bigtable service.
50 //
51 // 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.
52 type BigtableClient interface {
53 // Streams back the contents of all requested rows in key order, optionally
54 // applying the same Reader filter to each. Depending on their size,
55 // rows and cells may be broken up across multiple responses, but
56 // atomicity of each row will still be preserved. See the
57 // ReadRowsResponse documentation for details.
58 ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error)
59 // Returns a sample of row keys in the table. The returned row keys will
60 // delimit contiguous sections of the table of approximately equal size,
61 // which can be used to break up the data for distributed tasks like
62 // mapreduces.
63 SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error)
64 // Mutates a row atomically. Cells already present in the row are left
65 // unchanged unless explicitly changed by `mutation`.
66 MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error)
67 // Mutates multiple rows in a batch. Each individual row is mutated
68 // atomically as in MutateRow, but the entire batch is not executed
69 // atomically.
70 MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error)
71 // Mutates a row atomically based on the output of a predicate Reader filter.
72 CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
73 // Warm up associated instance metadata for this connection.
74 // This call is not required but may be useful for connection keep-alive.
75 PingAndWarm(ctx context.Context, in *PingAndWarmRequest, opts ...grpc.CallOption) (*PingAndWarmResponse, error)
76 // Modifies a row atomically on the server. The method reads the latest
77 // existing timestamp and value from the specified columns and writes a new
78 // entry based on pre-defined read/modify/write rules. The new value for the
79 // timestamp is the greater of the existing timestamp or the current server
80 // time. The method returns the new contents of all modified cells.
81 ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error)
82 // Returns the current list of partitions that make up the table's
83 // change stream. The union of partitions will cover the entire keyspace.
84 // Partitions can be read with `ReadChangeStream`.
85 // NOTE: This API is only intended to be used by Apache Beam BigtableIO.
86 GenerateInitialChangeStreamPartitions(ctx context.Context, in *GenerateInitialChangeStreamPartitionsRequest, opts ...grpc.CallOption) (Bigtable_GenerateInitialChangeStreamPartitionsClient, error)
87 // Reads changes from a table's change stream. Changes will
88 // reflect both user-initiated mutations and mutations that are caused by
89 // garbage collection.
90 // NOTE: This API is only intended to be used by Apache Beam BigtableIO.
91 ReadChangeStream(ctx context.Context, in *ReadChangeStreamRequest, opts ...grpc.CallOption) (Bigtable_ReadChangeStreamClient, error)
92 // Prepares a GoogleSQL query for execution on a particular Bigtable instance.
93 PrepareQuery(ctx context.Context, in *PrepareQueryRequest, opts ...grpc.CallOption) (*PrepareQueryResponse, error)
94 // Executes a SQL query against a particular Bigtable instance.
95 ExecuteQuery(ctx context.Context, in *ExecuteQueryRequest, opts ...grpc.CallOption) (Bigtable_ExecuteQueryClient, error)
96 }
97
98 type bigtableClient struct {
99 cc grpc.ClientConnInterface
100 }
101
102 func NewBigtableClient(cc grpc.ClientConnInterface) BigtableClient {
103 return &bigtableClient{cc}
104 }
105
106 func (c *bigtableClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (Bigtable_ReadRowsClient, error) {
107 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[0], Bigtable_ReadRows_FullMethodName, opts...)
108 if err != nil {
109 return nil, err
110 }
111 x := &bigtableReadRowsClient{stream}
112 if err := x.ClientStream.SendMsg(in); err != nil {
113 return nil, err
114 }
115 if err := x.ClientStream.CloseSend(); err != nil {
116 return nil, err
117 }
118 return x, nil
119 }
120
121 type Bigtable_ReadRowsClient interface {
122 Recv() (*ReadRowsResponse, error)
123 grpc.ClientStream
124 }
125
126 type bigtableReadRowsClient struct {
127 grpc.ClientStream
128 }
129
130 func (x *bigtableReadRowsClient) Recv() (*ReadRowsResponse, error) {
131 m := new(ReadRowsResponse)
132 if err := x.ClientStream.RecvMsg(m); err != nil {
133 return nil, err
134 }
135 return m, nil
136 }
137
138 func (c *bigtableClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (Bigtable_SampleRowKeysClient, error) {
139 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[1], Bigtable_SampleRowKeys_FullMethodName, opts...)
140 if err != nil {
141 return nil, err
142 }
143 x := &bigtableSampleRowKeysClient{stream}
144 if err := x.ClientStream.SendMsg(in); err != nil {
145 return nil, err
146 }
147 if err := x.ClientStream.CloseSend(); err != nil {
148 return nil, err
149 }
150 return x, nil
151 }
152
153 type Bigtable_SampleRowKeysClient interface {
154 Recv() (*SampleRowKeysResponse, error)
155 grpc.ClientStream
156 }
157
158 type bigtableSampleRowKeysClient struct {
159 grpc.ClientStream
160 }
161
162 func (x *bigtableSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) {
163 m := new(SampleRowKeysResponse)
164 if err := x.ClientStream.RecvMsg(m); err != nil {
165 return nil, err
166 }
167 return m, nil
168 }
169
170 func (c *bigtableClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*MutateRowResponse, error) {
171 out := new(MutateRowResponse)
172 err := c.cc.Invoke(ctx, Bigtable_MutateRow_FullMethodName, in, out, opts...)
173 if err != nil {
174 return nil, err
175 }
176 return out, nil
177 }
178
179 func (c *bigtableClient) MutateRows(ctx context.Context, in *MutateRowsRequest, opts ...grpc.CallOption) (Bigtable_MutateRowsClient, error) {
180 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[2], Bigtable_MutateRows_FullMethodName, opts...)
181 if err != nil {
182 return nil, err
183 }
184 x := &bigtableMutateRowsClient{stream}
185 if err := x.ClientStream.SendMsg(in); err != nil {
186 return nil, err
187 }
188 if err := x.ClientStream.CloseSend(); err != nil {
189 return nil, err
190 }
191 return x, nil
192 }
193
194 type Bigtable_MutateRowsClient interface {
195 Recv() (*MutateRowsResponse, error)
196 grpc.ClientStream
197 }
198
199 type bigtableMutateRowsClient struct {
200 grpc.ClientStream
201 }
202
203 func (x *bigtableMutateRowsClient) Recv() (*MutateRowsResponse, error) {
204 m := new(MutateRowsResponse)
205 if err := x.ClientStream.RecvMsg(m); err != nil {
206 return nil, err
207 }
208 return m, nil
209 }
210
211 func (c *bigtableClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) {
212 out := new(CheckAndMutateRowResponse)
213 err := c.cc.Invoke(ctx, Bigtable_CheckAndMutateRow_FullMethodName, in, out, opts...)
214 if err != nil {
215 return nil, err
216 }
217 return out, nil
218 }
219
220 func (c *bigtableClient) PingAndWarm(ctx context.Context, in *PingAndWarmRequest, opts ...grpc.CallOption) (*PingAndWarmResponse, error) {
221 out := new(PingAndWarmResponse)
222 err := c.cc.Invoke(ctx, Bigtable_PingAndWarm_FullMethodName, in, out, opts...)
223 if err != nil {
224 return nil, err
225 }
226 return out, nil
227 }
228
229 func (c *bigtableClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*ReadModifyWriteRowResponse, error) {
230 out := new(ReadModifyWriteRowResponse)
231 err := c.cc.Invoke(ctx, Bigtable_ReadModifyWriteRow_FullMethodName, in, out, opts...)
232 if err != nil {
233 return nil, err
234 }
235 return out, nil
236 }
237
238 func (c *bigtableClient) GenerateInitialChangeStreamPartitions(ctx context.Context, in *GenerateInitialChangeStreamPartitionsRequest, opts ...grpc.CallOption) (Bigtable_GenerateInitialChangeStreamPartitionsClient, error) {
239 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[3], Bigtable_GenerateInitialChangeStreamPartitions_FullMethodName, opts...)
240 if err != nil {
241 return nil, err
242 }
243 x := &bigtableGenerateInitialChangeStreamPartitionsClient{stream}
244 if err := x.ClientStream.SendMsg(in); err != nil {
245 return nil, err
246 }
247 if err := x.ClientStream.CloseSend(); err != nil {
248 return nil, err
249 }
250 return x, nil
251 }
252
253 type Bigtable_GenerateInitialChangeStreamPartitionsClient interface {
254 Recv() (*GenerateInitialChangeStreamPartitionsResponse, error)
255 grpc.ClientStream
256 }
257
258 type bigtableGenerateInitialChangeStreamPartitionsClient struct {
259 grpc.ClientStream
260 }
261
262 func (x *bigtableGenerateInitialChangeStreamPartitionsClient) Recv() (*GenerateInitialChangeStreamPartitionsResponse, error) {
263 m := new(GenerateInitialChangeStreamPartitionsResponse)
264 if err := x.ClientStream.RecvMsg(m); err != nil {
265 return nil, err
266 }
267 return m, nil
268 }
269
270 func (c *bigtableClient) ReadChangeStream(ctx context.Context, in *ReadChangeStreamRequest, opts ...grpc.CallOption) (Bigtable_ReadChangeStreamClient, error) {
271 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[4], Bigtable_ReadChangeStream_FullMethodName, opts...)
272 if err != nil {
273 return nil, err
274 }
275 x := &bigtableReadChangeStreamClient{stream}
276 if err := x.ClientStream.SendMsg(in); err != nil {
277 return nil, err
278 }
279 if err := x.ClientStream.CloseSend(); err != nil {
280 return nil, err
281 }
282 return x, nil
283 }
284
285 type Bigtable_ReadChangeStreamClient interface {
286 Recv() (*ReadChangeStreamResponse, error)
287 grpc.ClientStream
288 }
289
290 type bigtableReadChangeStreamClient struct {
291 grpc.ClientStream
292 }
293
294 func (x *bigtableReadChangeStreamClient) Recv() (*ReadChangeStreamResponse, error) {
295 m := new(ReadChangeStreamResponse)
296 if err := x.ClientStream.RecvMsg(m); err != nil {
297 return nil, err
298 }
299 return m, nil
300 }
301
302 func (c *bigtableClient) PrepareQuery(ctx context.Context, in *PrepareQueryRequest, opts ...grpc.CallOption) (*PrepareQueryResponse, error) {
303 out := new(PrepareQueryResponse)
304 err := c.cc.Invoke(ctx, Bigtable_PrepareQuery_FullMethodName, in, out, opts...)
305 if err != nil {
306 return nil, err
307 }
308 return out, nil
309 }
310
311 func (c *bigtableClient) ExecuteQuery(ctx context.Context, in *ExecuteQueryRequest, opts ...grpc.CallOption) (Bigtable_ExecuteQueryClient, error) {
312 stream, err := c.cc.NewStream(ctx, &Bigtable_ServiceDesc.Streams[5], Bigtable_ExecuteQuery_FullMethodName, opts...)
313 if err != nil {
314 return nil, err
315 }
316 x := &bigtableExecuteQueryClient{stream}
317 if err := x.ClientStream.SendMsg(in); err != nil {
318 return nil, err
319 }
320 if err := x.ClientStream.CloseSend(); err != nil {
321 return nil, err
322 }
323 return x, nil
324 }
325
326 type Bigtable_ExecuteQueryClient interface {
327 Recv() (*ExecuteQueryResponse, error)
328 grpc.ClientStream
329 }
330
331 type bigtableExecuteQueryClient struct {
332 grpc.ClientStream
333 }
334
335 func (x *bigtableExecuteQueryClient) Recv() (*ExecuteQueryResponse, error) {
336 m := new(ExecuteQueryResponse)
337 if err := x.ClientStream.RecvMsg(m); err != nil {
338 return nil, err
339 }
340 return m, nil
341 }
342
343 // BigtableServer is the server API for Bigtable service.
344 // All implementations should embed UnimplementedBigtableServer
345 // for forward compatibility
346 type BigtableServer interface {
347 // Streams back the contents of all requested rows in key order, optionally
348 // applying the same Reader filter to each. Depending on their size,
349 // rows and cells may be broken up across multiple responses, but
350 // atomicity of each row will still be preserved. See the
351 // ReadRowsResponse documentation for details.
352 ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error
353 // Returns a sample of row keys in the table. The returned row keys will
354 // delimit contiguous sections of the table of approximately equal size,
355 // which can be used to break up the data for distributed tasks like
356 // mapreduces.
357 SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error
358 // Mutates a row atomically. Cells already present in the row are left
359 // unchanged unless explicitly changed by `mutation`.
360 MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error)
361 // Mutates multiple rows in a batch. Each individual row is mutated
362 // atomically as in MutateRow, but the entire batch is not executed
363 // atomically.
364 MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error
365 // Mutates a row atomically based on the output of a predicate Reader filter.
366 CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
367 // Warm up associated instance metadata for this connection.
368 // This call is not required but may be useful for connection keep-alive.
369 PingAndWarm(context.Context, *PingAndWarmRequest) (*PingAndWarmResponse, error)
370 // Modifies a row atomically on the server. The method reads the latest
371 // existing timestamp and value from the specified columns and writes a new
372 // entry based on pre-defined read/modify/write rules. The new value for the
373 // timestamp is the greater of the existing timestamp or the current server
374 // time. The method returns the new contents of all modified cells.
375 ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error)
376 // Returns the current list of partitions that make up the table's
377 // change stream. The union of partitions will cover the entire keyspace.
378 // Partitions can be read with `ReadChangeStream`.
379 // NOTE: This API is only intended to be used by Apache Beam BigtableIO.
380 GenerateInitialChangeStreamPartitions(*GenerateInitialChangeStreamPartitionsRequest, Bigtable_GenerateInitialChangeStreamPartitionsServer) error
381 // Reads changes from a table's change stream. Changes will
382 // reflect both user-initiated mutations and mutations that are caused by
383 // garbage collection.
384 // NOTE: This API is only intended to be used by Apache Beam BigtableIO.
385 ReadChangeStream(*ReadChangeStreamRequest, Bigtable_ReadChangeStreamServer) error
386 // Prepares a GoogleSQL query for execution on a particular Bigtable instance.
387 PrepareQuery(context.Context, *PrepareQueryRequest) (*PrepareQueryResponse, error)
388 // Executes a SQL query against a particular Bigtable instance.
389 ExecuteQuery(*ExecuteQueryRequest, Bigtable_ExecuteQueryServer) error
390 }
391
392 // UnimplementedBigtableServer should be embedded to have forward compatible implementations.
393 type UnimplementedBigtableServer struct {
394 }
395
396 func (UnimplementedBigtableServer) ReadRows(*ReadRowsRequest, Bigtable_ReadRowsServer) error {
397 return status.Errorf(codes.Unimplemented, "method ReadRows not implemented")
398 }
399 func (UnimplementedBigtableServer) SampleRowKeys(*SampleRowKeysRequest, Bigtable_SampleRowKeysServer) error {
400 return status.Errorf(codes.Unimplemented, "method SampleRowKeys not implemented")
401 }
402 func (UnimplementedBigtableServer) MutateRow(context.Context, *MutateRowRequest) (*MutateRowResponse, error) {
403 return nil, status.Errorf(codes.Unimplemented, "method MutateRow not implemented")
404 }
405 func (UnimplementedBigtableServer) MutateRows(*MutateRowsRequest, Bigtable_MutateRowsServer) error {
406 return status.Errorf(codes.Unimplemented, "method MutateRows not implemented")
407 }
408 func (UnimplementedBigtableServer) CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error) {
409 return nil, status.Errorf(codes.Unimplemented, "method CheckAndMutateRow not implemented")
410 }
411 func (UnimplementedBigtableServer) PingAndWarm(context.Context, *PingAndWarmRequest) (*PingAndWarmResponse, error) {
412 return nil, status.Errorf(codes.Unimplemented, "method PingAndWarm not implemented")
413 }
414 func (UnimplementedBigtableServer) ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*ReadModifyWriteRowResponse, error) {
415 return nil, status.Errorf(codes.Unimplemented, "method ReadModifyWriteRow not implemented")
416 }
417 func (UnimplementedBigtableServer) GenerateInitialChangeStreamPartitions(*GenerateInitialChangeStreamPartitionsRequest, Bigtable_GenerateInitialChangeStreamPartitionsServer) error {
418 return status.Errorf(codes.Unimplemented, "method GenerateInitialChangeStreamPartitions not implemented")
419 }
420 func (UnimplementedBigtableServer) ReadChangeStream(*ReadChangeStreamRequest, Bigtable_ReadChangeStreamServer) error {
421 return status.Errorf(codes.Unimplemented, "method ReadChangeStream not implemented")
422 }
423 func (UnimplementedBigtableServer) PrepareQuery(context.Context, *PrepareQueryRequest) (*PrepareQueryResponse, error) {
424 return nil, status.Errorf(codes.Unimplemented, "method PrepareQuery not implemented")
425 }
426 func (UnimplementedBigtableServer) ExecuteQuery(*ExecuteQueryRequest, Bigtable_ExecuteQueryServer) error {
427 return status.Errorf(codes.Unimplemented, "method ExecuteQuery not implemented")
428 }
429
430 // UnsafeBigtableServer may be embedded to opt out of forward compatibility for this service.
431 // Use of this interface is not recommended, as added methods to BigtableServer will
432 // result in compilation errors.
433 type UnsafeBigtableServer interface {
434 mustEmbedUnimplementedBigtableServer()
435 }
436
437 func RegisterBigtableServer(s grpc.ServiceRegistrar, srv BigtableServer) {
438 s.RegisterService(&Bigtable_ServiceDesc, srv)
439 }
440
441 func _Bigtable_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error {
442 m := new(ReadRowsRequest)
443 if err := stream.RecvMsg(m); err != nil {
444 return err
445 }
446 return srv.(BigtableServer).ReadRows(m, &bigtableReadRowsServer{stream})
447 }
448
449 type Bigtable_ReadRowsServer interface {
450 Send(*ReadRowsResponse) error
451 grpc.ServerStream
452 }
453
454 type bigtableReadRowsServer struct {
455 grpc.ServerStream
456 }
457
458 func (x *bigtableReadRowsServer) Send(m *ReadRowsResponse) error {
459 return x.ServerStream.SendMsg(m)
460 }
461
462 func _Bigtable_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
463 m := new(SampleRowKeysRequest)
464 if err := stream.RecvMsg(m); err != nil {
465 return err
466 }
467 return srv.(BigtableServer).SampleRowKeys(m, &bigtableSampleRowKeysServer{stream})
468 }
469
470 type Bigtable_SampleRowKeysServer interface {
471 Send(*SampleRowKeysResponse) error
472 grpc.ServerStream
473 }
474
475 type bigtableSampleRowKeysServer struct {
476 grpc.ServerStream
477 }
478
479 func (x *bigtableSampleRowKeysServer) Send(m *SampleRowKeysResponse) error {
480 return x.ServerStream.SendMsg(m)
481 }
482
483 func _Bigtable_MutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
484 in := new(MutateRowRequest)
485 if err := dec(in); err != nil {
486 return nil, err
487 }
488 if interceptor == nil {
489 return srv.(BigtableServer).MutateRow(ctx, in)
490 }
491 info := &grpc.UnaryServerInfo{
492 Server: srv,
493 FullMethod: Bigtable_MutateRow_FullMethodName,
494 }
495 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
496 return srv.(BigtableServer).MutateRow(ctx, req.(*MutateRowRequest))
497 }
498 return interceptor(ctx, in, info, handler)
499 }
500
501 func _Bigtable_MutateRows_Handler(srv interface{}, stream grpc.ServerStream) error {
502 m := new(MutateRowsRequest)
503 if err := stream.RecvMsg(m); err != nil {
504 return err
505 }
506 return srv.(BigtableServer).MutateRows(m, &bigtableMutateRowsServer{stream})
507 }
508
509 type Bigtable_MutateRowsServer interface {
510 Send(*MutateRowsResponse) error
511 grpc.ServerStream
512 }
513
514 type bigtableMutateRowsServer struct {
515 grpc.ServerStream
516 }
517
518 func (x *bigtableMutateRowsServer) Send(m *MutateRowsResponse) error {
519 return x.ServerStream.SendMsg(m)
520 }
521
522 func _Bigtable_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
523 in := new(CheckAndMutateRowRequest)
524 if err := dec(in); err != nil {
525 return nil, err
526 }
527 if interceptor == nil {
528 return srv.(BigtableServer).CheckAndMutateRow(ctx, in)
529 }
530 info := &grpc.UnaryServerInfo{
531 Server: srv,
532 FullMethod: Bigtable_CheckAndMutateRow_FullMethodName,
533 }
534 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
535 return srv.(BigtableServer).CheckAndMutateRow(ctx, req.(*CheckAndMutateRowRequest))
536 }
537 return interceptor(ctx, in, info, handler)
538 }
539
540 func _Bigtable_PingAndWarm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
541 in := new(PingAndWarmRequest)
542 if err := dec(in); err != nil {
543 return nil, err
544 }
545 if interceptor == nil {
546 return srv.(BigtableServer).PingAndWarm(ctx, in)
547 }
548 info := &grpc.UnaryServerInfo{
549 Server: srv,
550 FullMethod: Bigtable_PingAndWarm_FullMethodName,
551 }
552 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
553 return srv.(BigtableServer).PingAndWarm(ctx, req.(*PingAndWarmRequest))
554 }
555 return interceptor(ctx, in, info, handler)
556 }
557
558 func _Bigtable_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
559 in := new(ReadModifyWriteRowRequest)
560 if err := dec(in); err != nil {
561 return nil, err
562 }
563 if interceptor == nil {
564 return srv.(BigtableServer).ReadModifyWriteRow(ctx, in)
565 }
566 info := &grpc.UnaryServerInfo{
567 Server: srv,
568 FullMethod: Bigtable_ReadModifyWriteRow_FullMethodName,
569 }
570 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
571 return srv.(BigtableServer).ReadModifyWriteRow(ctx, req.(*ReadModifyWriteRowRequest))
572 }
573 return interceptor(ctx, in, info, handler)
574 }
575
576 func _Bigtable_GenerateInitialChangeStreamPartitions_Handler(srv interface{}, stream grpc.ServerStream) error {
577 m := new(GenerateInitialChangeStreamPartitionsRequest)
578 if err := stream.RecvMsg(m); err != nil {
579 return err
580 }
581 return srv.(BigtableServer).GenerateInitialChangeStreamPartitions(m, &bigtableGenerateInitialChangeStreamPartitionsServer{stream})
582 }
583
584 type Bigtable_GenerateInitialChangeStreamPartitionsServer interface {
585 Send(*GenerateInitialChangeStreamPartitionsResponse) error
586 grpc.ServerStream
587 }
588
589 type bigtableGenerateInitialChangeStreamPartitionsServer struct {
590 grpc.ServerStream
591 }
592
593 func (x *bigtableGenerateInitialChangeStreamPartitionsServer) Send(m *GenerateInitialChangeStreamPartitionsResponse) error {
594 return x.ServerStream.SendMsg(m)
595 }
596
597 func _Bigtable_ReadChangeStream_Handler(srv interface{}, stream grpc.ServerStream) error {
598 m := new(ReadChangeStreamRequest)
599 if err := stream.RecvMsg(m); err != nil {
600 return err
601 }
602 return srv.(BigtableServer).ReadChangeStream(m, &bigtableReadChangeStreamServer{stream})
603 }
604
605 type Bigtable_ReadChangeStreamServer interface {
606 Send(*ReadChangeStreamResponse) error
607 grpc.ServerStream
608 }
609
610 type bigtableReadChangeStreamServer struct {
611 grpc.ServerStream
612 }
613
614 func (x *bigtableReadChangeStreamServer) Send(m *ReadChangeStreamResponse) error {
615 return x.ServerStream.SendMsg(m)
616 }
617
618 func _Bigtable_PrepareQuery_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
619 in := new(PrepareQueryRequest)
620 if err := dec(in); err != nil {
621 return nil, err
622 }
623 if interceptor == nil {
624 return srv.(BigtableServer).PrepareQuery(ctx, in)
625 }
626 info := &grpc.UnaryServerInfo{
627 Server: srv,
628 FullMethod: Bigtable_PrepareQuery_FullMethodName,
629 }
630 handler := func(ctx context.Context, req interface{}) (interface{}, error) {
631 return srv.(BigtableServer).PrepareQuery(ctx, req.(*PrepareQueryRequest))
632 }
633 return interceptor(ctx, in, info, handler)
634 }
635
636 func _Bigtable_ExecuteQuery_Handler(srv interface{}, stream grpc.ServerStream) error {
637 m := new(ExecuteQueryRequest)
638 if err := stream.RecvMsg(m); err != nil {
639 return err
640 }
641 return srv.(BigtableServer).ExecuteQuery(m, &bigtableExecuteQueryServer{stream})
642 }
643
644 type Bigtable_ExecuteQueryServer interface {
645 Send(*ExecuteQueryResponse) error
646 grpc.ServerStream
647 }
648
649 type bigtableExecuteQueryServer struct {
650 grpc.ServerStream
651 }
652
653 func (x *bigtableExecuteQueryServer) Send(m *ExecuteQueryResponse) error {
654 return x.ServerStream.SendMsg(m)
655 }
656
657 // Bigtable_ServiceDesc is the grpc.ServiceDesc for Bigtable service.
658 // It's only intended for direct use with grpc.RegisterService,
659 // and not to be introspected or modified (even as a copy)
660 var Bigtable_ServiceDesc = grpc.ServiceDesc{
661 ServiceName: "google.bigtable.v2.Bigtable",
662 HandlerType: (*BigtableServer)(nil),
663 Methods: []grpc.MethodDesc{
664 {
665 MethodName: "MutateRow",
666 Handler: _Bigtable_MutateRow_Handler,
667 },
668 {
669 MethodName: "CheckAndMutateRow",
670 Handler: _Bigtable_CheckAndMutateRow_Handler,
671 },
672 {
673 MethodName: "PingAndWarm",
674 Handler: _Bigtable_PingAndWarm_Handler,
675 },
676 {
677 MethodName: "ReadModifyWriteRow",
678 Handler: _Bigtable_ReadModifyWriteRow_Handler,
679 },
680 {
681 MethodName: "PrepareQuery",
682 Handler: _Bigtable_PrepareQuery_Handler,
683 },
684 },
685 Streams: []grpc.StreamDesc{
686 {
687 StreamName: "ReadRows",
688 Handler: _Bigtable_ReadRows_Handler,
689 ServerStreams: true,
690 },
691 {
692 StreamName: "SampleRowKeys",
693 Handler: _Bigtable_SampleRowKeys_Handler,
694 ServerStreams: true,
695 },
696 {
697 StreamName: "MutateRows",
698 Handler: _Bigtable_MutateRows_Handler,
699 ServerStreams: true,
700 },
701 {
702 StreamName: "GenerateInitialChangeStreamPartitions",
703 Handler: _Bigtable_GenerateInitialChangeStreamPartitions_Handler,
704 ServerStreams: true,
705 },
706 {
707 StreamName: "ReadChangeStream",
708 Handler: _Bigtable_ReadChangeStream_Handler,
709 ServerStreams: true,
710 },
711 {
712 StreamName: "ExecuteQuery",
713 Handler: _Bigtable_ExecuteQuery_Handler,
714 ServerStreams: true,
715 },
716 },
717 Metadata: "google/bigtable/v2/bigtable.proto",
718 }