Package cloud.google.com/go/bigquery/storage/apiv1beta2/storagepb (v1.71.0)

const (
	BigQueryRead_CreateReadSession_FullMethodName = "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/CreateReadSession"
	BigQueryRead_ReadRows_FullMethodName          = "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/ReadRows"
	BigQueryRead_SplitReadStream_FullMethodName   = "/google.cloud.bigquery.storage.v1beta2.BigQueryRead/SplitReadStream"
)

const (
	BigQueryWrite_CreateWriteStream_FullMethodName       = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/CreateWriteStream"
	BigQueryWrite_AppendRows_FullMethodName              = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/AppendRows"
	BigQueryWrite_GetWriteStream_FullMethodName          = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/GetWriteStream"
	BigQueryWrite_FinalizeWriteStream_FullMethodName     = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/FinalizeWriteStream"
	BigQueryWrite_BatchCommitWriteStreams_FullMethodName = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/BatchCommitWriteStreams"
	BigQueryWrite_FlushRows_FullMethodName               = "/google.cloud.bigquery.storage.v1beta2.BigQueryWrite/FlushRows"
)

var (
	ArrowSerializationOptions_Format_name = map[int32]string{
		0: "FORMAT_UNSPECIFIED",
		1: "ARROW_0_14",
		2: "ARROW_0_15",
	}
	ArrowSerializationOptions_Format_value = map[string]int32{
		"FORMAT_UNSPECIFIED": 0,
		"ARROW_0_14":         1,
		"ARROW_0_15":         2,
	}
)

var (
	StorageError_StorageErrorCode_name = map[int32]string{
		0: "STORAGE_ERROR_CODE_UNSPECIFIED",
		1: "TABLE_NOT_FOUND",
		2: "STREAM_ALREADY_COMMITTED",
		3: "STREAM_NOT_FOUND",
		4: "INVALID_STREAM_TYPE",
		5: "INVALID_STREAM_STATE",
		6: "STREAM_FINALIZED",
	}
	StorageError_StorageErrorCode_value = map[string]int32{
		"STORAGE_ERROR_CODE_UNSPECIFIED": 0,
		"TABLE_NOT_FOUND":                1,
		"STREAM_ALREADY_COMMITTED":       2,
		"STREAM_NOT_FOUND":               3,
		"INVALID_STREAM_TYPE":            4,
		"INVALID_STREAM_STATE":           5,
		"STREAM_FINALIZED":               6,
	}
)

var (
	DataFormat_name = map[int32]string{
		0: "DATA_FORMAT_UNSPECIFIED",
		1: "AVRO",
		2: "ARROW",
	}
	DataFormat_value = map[string]int32{
		"DATA_FORMAT_UNSPECIFIED": 0,
		"AVRO":                    1,
		"ARROW":                   2,
	}
)

var (
	WriteStream_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "COMMITTED",
		2: "PENDING",
		3: "BUFFERED",
	}
	WriteStream_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"COMMITTED":        1,
		"PENDING":          2,
		"BUFFERED":         3,
	}
)

var (
	TableFieldSchema_Type_name = map[int32]string{
		0:  "TYPE_UNSPECIFIED",
		1:  "STRING",
		2:  "INT64",
		3:  "DOUBLE",
		4:  "STRUCT",
		5:  "BYTES",
		6:  "BOOL",
		7:  "TIMESTAMP",
		8:  "DATE",
		9:  "TIME",
		10: "DATETIME",
		11: "GEOGRAPHY",
		12: "NUMERIC",
		13: "BIGNUMERIC",
		14: "INTERVAL",
		15: "JSON",
	}
	TableFieldSchema_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"STRING":           1,
		"INT64":            2,
		"DOUBLE":           3,
		"STRUCT":           4,
		"BYTES":            5,
		"BOOL":             6,
		"TIMESTAMP":        7,
		"DATE":             8,
		"TIME":             9,
		"DATETIME":         10,
		"GEOGRAPHY":        11,
		"NUMERIC":          12,
		"BIGNUMERIC":       13,
		"INTERVAL":         14,
		"JSON":             15,
	}
)

var (
	TableFieldSchema_Mode_name = map[int32]string{
		0: "MODE_UNSPECIFIED",
		1: "NULLABLE",
		2: "REQUIRED",
		3: "REPEATED",
	}
	TableFieldSchema_Mode_value = map[string]int32{
		"MODE_UNSPECIFIED": 0,
		"NULLABLE":         1,
		"REQUIRED":         2,
		"REPEATED":         3,
	}
)

var BigQueryRead_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.storage.v1beta2.BigQueryRead",
	HandlerType: (*BigQueryReadServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateReadSession",
			Handler:    _BigQueryRead_CreateReadSession_Handler,
		},
		{
			MethodName: "SplitReadStream",
			Handler:    _BigQueryRead_SplitReadStream_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ReadRows",
			Handler:       _BigQueryRead_ReadRows_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "google/cloud/bigquery/storage/v1beta2/storage.proto",
}

var BigQueryWrite_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "google.cloud.bigquery.storage.v1beta2.BigQueryWrite",
	HandlerType: (*BigQueryWriteServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateWriteStream",
			Handler:    _BigQueryWrite_CreateWriteStream_Handler,
		},
		{
			MethodName: "GetWriteStream",
			Handler:    _BigQueryWrite_GetWriteStream_Handler,
		},
		{
			MethodName: "FinalizeWriteStream",
			Handler:    _BigQueryWrite_FinalizeWriteStream_Handler,
		},
		{
			MethodName: "BatchCommitWriteStreams",
			Handler:    _BigQueryWrite_BatchCommitWriteStreams_Handler,
		},
		{
			MethodName: "FlushRows",
			Handler:    _BigQueryWrite_FlushRows_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "AppendRows",
			Handler:       _BigQueryWrite_AppendRows_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "google/cloud/bigquery/storage/v1beta2/storage.proto",
}

var File_google_cloud_bigquery_storage_v1beta2_arrow_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1beta2_avro_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1beta2_protobuf_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1beta2_storage_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1beta2_stream_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1beta2_table_proto protoreflect.FileDescriptor

func RegisterBigQueryReadServer(s grpc.ServiceRegistrar, srv BigQueryReadServer)

func RegisterBigQueryWriteServer(s grpc.ServiceRegistrar, srv BigQueryWriteServer)

type AppendRowsRequest struct {

	// Required. The stream that is the target of the append operation. This value
	// must be specified for the initial request. If subsequent requests specify
	// the stream name, it must equal to the value provided in the first request.
	// To write to the _default stream, populate this field with a string in the
	// format `projects/{project}/datasets/{dataset}/tables/{table}/_default`.
	WriteStream string `protobuf:"bytes,1,opt,name=write_stream,json=writeStream,proto3" json:"write_stream,omitempty"`
	// If present, the write is only performed if the next append offset is same
	// as the provided value. If not present, the write is performed at the
	// current end of stream. Specifying a value for this field is not allowed
	// when calling AppendRows for the '_default' stream.
	Offset *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// Input rows. The `writer_schema` field must be specified at the initial
	// request and currently, it will be ignored if specified in following
	// requests. Following requests must have data in the same format as the
	// initial request.
	//
	// Types that are assignable to Rows:
	//
	//	*AppendRowsRequest_ProtoRows
	Rows isAppendRowsRequest_Rows `protobuf_oneof:"rows"`
	// Id set by client to annotate its identity. Only initial request setting is
	// respected.
	TraceId string `protobuf:"bytes,6,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`
	// contains filtered or unexported fields
}

func (*AppendRowsRequest) Descriptor() ([]byte, []int)

func (x *AppendRowsRequest) GetOffset() *wrapperspb.Int64Value

func (x *AppendRowsRequest) GetProtoRows() *AppendRowsRequest_ProtoData

func (m *AppendRowsRequest) GetRows() isAppendRowsRequest_Rows

func (x *AppendRowsRequest) GetTraceId() string

func (x *AppendRowsRequest) GetWriteStream() string

func (*AppendRowsRequest) ProtoMessage()

func (x *AppendRowsRequest) ProtoReflect() protoreflect.Message

func (x *AppendRowsRequest) Reset()

func (x *AppendRowsRequest) String() string

type AppendRowsRequest_ProtoData struct {

	// Proto schema used to serialize the data.
	WriterSchema *ProtoSchema `protobuf:"bytes,1,opt,name=writer_schema,json=writerSchema,proto3" json:"writer_schema,omitempty"`
	// Serialized row data in protobuf message format.
	Rows *ProtoRows `protobuf:"bytes,2,opt,name=rows,proto3" json:"rows,omitempty"`
	// contains filtered or unexported fields
}

func (*AppendRowsRequest_ProtoData) Descriptor() ([]byte, []int)

func (x *AppendRowsRequest_ProtoData) GetRows() *ProtoRows

func (x *AppendRowsRequest_ProtoData) GetWriterSchema() *ProtoSchema

func (*AppendRowsRequest_ProtoData) ProtoMessage()

func (x *AppendRowsRequest_ProtoData) ProtoReflect() protoreflect.Message

func (x *AppendRowsRequest_ProtoData) Reset()

func (x *AppendRowsRequest_ProtoData) String() string

type AppendRowsRequest_ProtoRows struct {
	// Rows in proto format.
	ProtoRows *AppendRowsRequest_ProtoData `protobuf:"bytes,4,opt,name=proto_rows,json=protoRows,proto3,oneof"`
}

type AppendRowsResponse struct {

	// Types that are assignable to Response:
	//
	//	*AppendRowsResponse_AppendResult_
	//	*AppendRowsResponse_Error
	Response isAppendRowsResponse_Response `protobuf_oneof:"response"`
	// If backend detects a schema update, pass it to user so that user can
	// use it to input new type of message. It will be empty when no schema
	// updates have occurred.
	UpdatedSchema *TableSchema `protobuf:"bytes,3,opt,name=updated_schema,json=updatedSchema,proto3" json:"updated_schema,omitempty"`
	// contains filtered or unexported fields
}

func (*AppendRowsResponse) Descriptor() ([]byte, []int)

func (x *AppendRowsResponse) GetAppendResult() *AppendRowsResponse_AppendResult

func (x *AppendRowsResponse) GetError() *status.Status

func (m *AppendRowsResponse) GetResponse() isAppendRowsResponse_Response

func (x *AppendRowsResponse) GetUpdatedSchema() *TableSchema

func (*AppendRowsResponse) ProtoMessage()

func (x *AppendRowsResponse) ProtoReflect() protoreflect.Message

func (x *AppendRowsResponse) Reset()

func (x *AppendRowsResponse) String() string

type AppendRowsResponse_AppendResult struct {

	// The row offset at which the last append occurred. The offset will not be
	// set if appending using default streams.
	Offset *wrapperspb.Int64Value `protobuf:"bytes,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

func (*AppendRowsResponse_AppendResult) Descriptor() ([]byte, []int)

func (x *AppendRowsResponse_AppendResult) GetOffset() *wrapperspb.Int64Value

func (*AppendRowsResponse_AppendResult) ProtoMessage()

func (x *AppendRowsResponse_AppendResult) ProtoReflect() protoreflect.Message

func (x *AppendRowsResponse_AppendResult) Reset()

func (x *AppendRowsResponse_AppendResult) String() string

type AppendRowsResponse_AppendResult_ struct {
	// Result if the append is successful.
	AppendResult *AppendRowsResponse_AppendResult `protobuf:"bytes,1,opt,name=append_result,json=appendResult,proto3,oneof"`
}

type AppendRowsResponse_Error struct {
	// Error returned when problems were encountered.  If present,
	// it indicates rows were not accepted into the system.
	// Users can retry or continue with other append requests within the
	// same connection.
	//
	// Additional information about error signalling:
	//
	// ALREADY_EXISTS: Happens when an append specified an offset, and the
	// backend already has received data at this offset.  Typically encountered
	// in retry scenarios, and can be ignored.
	//
	// OUT_OF_RANGE: Returned when the specified offset in the stream is beyond
	// the current end of the stream.
	//
	// INVALID_ARGUMENT: Indicates a malformed request or data.
	//
	// ABORTED: Request processing is aborted because of prior failures.  The
	// request can be retried if previous failure is addressed.
	//
	// INTERNAL: Indicates server side error(s) that can be retried.
	Error *status.Status `protobuf:"bytes,2,opt,name=error,proto3,oneof"`
}

type ArrowRecordBatch struct {

	// IPC-serialized Arrow RecordBatch.
	SerializedRecordBatch []byte `protobuf:"bytes,1,opt,name=serialized_record_batch,json=serializedRecordBatch,proto3" json:"serialized_record_batch,omitempty"`
	// contains filtered or unexported fields
}

func (*ArrowRecordBatch) Descriptor() ([]byte, []int)

func (x *ArrowRecordBatch) GetSerializedRecordBatch() []byte

func (*ArrowRecordBatch) ProtoMessage()

func (x *ArrowRecordBatch) ProtoReflect() protoreflect.Message

func (x *ArrowRecordBatch) Reset()

func (x *ArrowRecordBatch) String() string

type ArrowSchema struct {

	// IPC serialized Arrow schema.
	SerializedSchema []byte `protobuf:"bytes,1,opt,name=serialized_schema,json=serializedSchema,proto3" json:"serialized_schema,omitempty"`
	// contains filtered or unexported fields
}

func (*ArrowSchema) Descriptor() ([]byte, []int)

func (x *ArrowSchema) GetSerializedSchema() []byte

func (*ArrowSchema) ProtoMessage()

func (x *ArrowSchema) ProtoReflect() protoreflect.Message

func (x *ArrowSchema) Reset()

func (x *ArrowSchema) String() string

type ArrowSerializationOptions struct {

	// The Arrow IPC format to use.
	Format ArrowSerializationOptions_Format `protobuf:"varint,1,opt,name=format,proto3,enum=google.cloud.bigquery.storage.v1beta2.ArrowSerializationOptions_Format" json:"format,omitempty"`
	// contains filtered or unexported fields
}

func (*ArrowSerializationOptions) Descriptor() ([]byte, []int)

func (x *ArrowSerializationOptions) GetFormat() ArrowSerializationOptions_Format

func (*ArrowSerializationOptions) ProtoMessage()

func (x *ArrowSerializationOptions) ProtoReflect() protoreflect.Message

func (x *ArrowSerializationOptions) Reset()

func (x *ArrowSerializationOptions) String() string

type ArrowSerializationOptions_Format int32

const (
	// If unspecied the IPC format as of 0.15 release will be used.
	ArrowSerializationOptions_FORMAT_UNSPECIFIED ArrowSerializationOptions_Format = 0
	// Use the legacy IPC message format as of Apache Arrow Release 0.14.
	ArrowSerializationOptions_ARROW_0_14 ArrowSerializationOptions_Format = 1
	// Use the message format as of Apache Arrow Release 0.15.
	ArrowSerializationOptions_ARROW_0_15 ArrowSerializationOptions_Format = 2
)

func (ArrowSerializationOptions_Format) Descriptor() protoreflect.EnumDescriptor

func (x ArrowSerializationOptions_Format) Enum() *ArrowSerializationOptions_Format

func (ArrowSerializationOptions_Format) EnumDescriptor() ([]byte, []int)

func (x ArrowSerializationOptions_Format) Number() protoreflect.EnumNumber

func (x ArrowSerializationOptions_Format) String() string

func (ArrowSerializationOptions_Format) Type() protoreflect.EnumType

type AvroRows struct {

	// Binary serialized rows in a block.
	SerializedBinaryRows []byte `protobuf:"bytes,1,opt,name=serialized_binary_rows,json=serializedBinaryRows,proto3" json:"serialized_binary_rows,omitempty"`
	// contains filtered or unexported fields
}

func (*AvroRows) Descriptor() ([]byte, []int)

func (x *AvroRows) GetSerializedBinaryRows() []byte

func (*AvroRows) ProtoMessage()

func (x *AvroRows) ProtoReflect() protoreflect.Message

func (x *AvroRows) Reset()

func (x *AvroRows) String() string

type AvroSchema struct {

	// Json serialized schema, as described at
	// https://avro.apache.org/docs/1.8.1/spec.html.
	Schema string `protobuf:"bytes,1,opt,name=schema,proto3" json:"schema,omitempty"`
	// contains filtered or unexported fields
}

func (*AvroSchema) Descriptor() ([]byte, []int)

func (x *AvroSchema) GetSchema() string

func (*AvroSchema) ProtoMessage()

func (x *AvroSchema) ProtoReflect() protoreflect.Message

func (x *AvroSchema) Reset()

func (x *AvroSchema) String() string

type BatchCommitWriteStreamsRequest struct {

	// Required. Parent table that all the streams should belong to, in the form
	// of `projects/{project}/datasets/{dataset}/tables/{table}`.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. The group of streams that will be committed atomically.
	WriteStreams []string `protobuf:"bytes,2,rep,name=write_streams,json=writeStreams,proto3" json:"write_streams,omitempty"`
	// contains filtered or unexported fields
}

func (*BatchCommitWriteStreamsRequest) Descriptor() ([]byte, []int)

func (x *BatchCommitWriteStreamsRequest) GetParent() string

func (x *BatchCommitWriteStreamsRequest) GetWriteStreams() []string

func (*BatchCommitWriteStreamsRequest) ProtoMessage()

func (x *BatchCommitWriteStreamsRequest) ProtoReflect() protoreflect.Message

func (x *BatchCommitWriteStreamsRequest) Reset()

func (x *BatchCommitWriteStreamsRequest) String() string

type BatchCommitWriteStreamsResponse struct {

	// The time at which streams were committed in microseconds granularity.
	// This field will only exist when there are no stream errors.
	// **Note** if this field is not set, it means the commit was not successful.
	CommitTime *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=commit_time,json=commitTime,proto3" json:"commit_time,omitempty"`
	// Stream level error if commit failed. Only streams with error will be in
	// the list.
	// If empty, there is no error and all streams are committed successfully.
	// If non empty, certain streams have errors and ZERO stream is committed due
	// to atomicity guarantee.
	StreamErrors []*StorageError `protobuf:"bytes,2,rep,name=stream_errors,json=streamErrors,proto3" json:"stream_errors,omitempty"`
	// contains filtered or unexported fields
}

func (*BatchCommitWriteStreamsResponse) Descriptor() ([]byte, []int)

func (x *BatchCommitWriteStreamsResponse) GetCommitTime() *timestamppb.Timestamp

func (x *BatchCommitWriteStreamsResponse) GetStreamErrors() []*StorageError

func (*BatchCommitWriteStreamsResponse) ProtoMessage()

func (x *BatchCommitWriteStreamsResponse) ProtoReflect() protoreflect.Message

func (x *BatchCommitWriteStreamsResponse) Reset()

func (x *BatchCommitWriteStreamsResponse) String() string

type BigQueryReadClient interface {
	// Creates a new read session. A read session divides the contents of a
	// BigQuery table into one or more streams, which can then be used to read
	// data from the table. The read session also specifies properties of the
	// data to be read, such as a list of columns or a push-down filter describing
	// the rows to be returned.
	//
	// A particular row can be read by at most one stream. When the caller has
	// reached the end of each stream in the session, then all the data in the
	// table has been read.
	//
	// Data is assigned to each stream such that roughly the same number of
	// rows can be read from each stream. Because the server-side unit for
	// assigning data is collections of rows, the API does not guarantee that
	// each stream will return the same number or rows. Additionally, the
	// limits are enforced based on the number of pre-filtered rows, so some
	// filters can lead to lopsided assignments.
	//
	// Read sessions automatically expire 6 hours after they are created and do
	// not require manual clean-up by the caller.
	CreateReadSession(ctx context.Context, in *CreateReadSessionRequest, opts ...grpc.CallOption) (*ReadSession, error)
	// Reads rows from the stream in the format prescribed by the ReadSession.
	// Each response contains one or more table rows, up to a maximum of 100 MiB
	// per response; read requests which attempt to read individual rows larger
	// than 100 MiB will fail.
	//
	// Each request also returns a set of stream statistics reflecting the current
	// state of the stream.
	ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigQueryRead_ReadRowsClient, error)
	// Splits a given `ReadStream` into two `ReadStream` objects. These
	// `ReadStream` objects are referred to as the primary and the residual
	// streams of the split. The original `ReadStream` can still be read from in
	// the same manner as before. Both of the returned `ReadStream` objects can
	// also be read from, and the rows returned by both child streams will be
	// the same as the rows read from the original stream.
	//
	// Moreover, the two child streams will be allocated back-to-back in the
	// original `ReadStream`. Concretely, it is guaranteed that for streams
	// original, primary, and residual, that original[0-j] = primary[0-j] and
	// original[j-n] = residual[0-m] once the streams have been read to
	// completion.
	SplitReadStream(ctx context.Context, in *SplitReadStreamRequest, opts ...grpc.CallOption) (*SplitReadStreamResponse, error)
}

func NewBigQueryReadClient(cc grpc.ClientConnInterface) BigQueryReadClient

type BigQueryReadServer interface {
	// Creates a new read session. A read session divides the contents of a
	// BigQuery table into one or more streams, which can then be used to read
	// data from the table. The read session also specifies properties of the
	// data to be read, such as a list of columns or a push-down filter describing
	// the rows to be returned.
	//
	// A particular row can be read by at most one stream. When the caller has
	// reached the end of each stream in the session, then all the data in the
	// table has been read.
	//
	// Data is assigned to each stream such that roughly the same number of
	// rows can be read from each stream. Because the server-side unit for
	// assigning data is collections of rows, the API does not guarantee that
	// each stream will return the same number or rows. Additionally, the
	// limits are enforced based on the number of pre-filtered rows, so some
	// filters can lead to lopsided assignments.
	//
	// Read sessions automatically expire 6 hours after they are created and do
	// not require manual clean-up by the caller.
	CreateReadSession(context.Context, *CreateReadSessionRequest) (*ReadSession, error)
	// Reads rows from the stream in the format prescribed by the ReadSession.
	// Each response contains one or more table rows, up to a maximum of 100 MiB
	// per response; read requests which attempt to read individual rows larger
	// than 100 MiB will fail.
	//
	// Each request also returns a set of stream statistics reflecting the current
	// state of the stream.
	ReadRows(*ReadRowsRequest, BigQueryRead_ReadRowsServer) error
	// Splits a given `ReadStream` into two `ReadStream` objects. These
	// `ReadStream` objects are referred to as the primary and the residual
	// streams of the split. The original `ReadStream` can still be read from in
	// the same manner as before. Both of the returned `ReadStream` objects can
	// also be read from, and the rows returned by both child streams will be
	// the same as the rows read from the original stream.
	//
	// Moreover, the two child streams will be allocated back-to-back in the
	// original `ReadStream`. Concretely, it is guaranteed that for streams
	// original, primary, and residual, that original[0-j] = primary[0-j] and
	// original[j-n] = residual[0-m] once the streams have been read to
	// completion.
	SplitReadStream(context.Context, *SplitReadStreamRequest) (*SplitReadStreamResponse, error)
}

type BigQueryRead_ReadRowsClient interface {
	Recv() (*ReadRowsResponse, error)
	grpc.ClientStream
}

type BigQueryRead_ReadRowsServer interface {
	Send(*ReadRowsResponse) error
	grpc.ServerStream
}

type BigQueryWriteClient interface {
	// Deprecated: Do not use.
	// Creates a write stream to the given table.
	// Additionally, every table has a special COMMITTED stream named '_default'
	// to which data can be written. This stream doesn't need to be created using
	// CreateWriteStream. It is a stream that can be used simultaneously by any
	// number of clients. Data written to this stream is considered committed as
	// soon as an acknowledgement is received.
	CreateWriteStream(ctx context.Context, in *CreateWriteStreamRequest, opts ...grpc.CallOption) (*WriteStream, error)
	// Deprecated: Do not use.
	// Appends data to the given stream.
	//
	// If `offset` is specified, the `offset` is checked against the end of
	// stream. The server returns `OUT_OF_RANGE` in `AppendRowsResponse` if an
	// attempt is made to append to an offset beyond the current end of the stream
	// or `ALREADY_EXISTS` if user provids an `offset` that has already been
	// written to. User can retry with adjusted offset within the same RPC
	// stream. If `offset` is not specified, append happens at the end of the
	// stream.
	//
	// The response contains the offset at which the append happened. Responses
	// are received in the same order in which requests are sent. There will be
	// one response for each successful request. If the `offset` is not set in
	// response, it means append didn't happen due to some errors. If one request
	// fails, all the subsequent requests will also fail until a success request
	// is made again.
	//
	// If the stream is of `PENDING` type, data will only be available for read
	// operations after the stream is committed.
	AppendRows(ctx context.Context, opts ...grpc.CallOption) (BigQueryWrite_AppendRowsClient, error)
	// Deprecated: Do not use.
	// Gets a write stream.
	GetWriteStream(ctx context.Context, in *GetWriteStreamRequest, opts ...grpc.CallOption) (*WriteStream, error)
	// Deprecated: Do not use.
	// Finalize a write stream so that no new data can be appended to the
	// stream. Finalize is not supported on the '_default' stream.
	FinalizeWriteStream(ctx context.Context, in *FinalizeWriteStreamRequest, opts ...grpc.CallOption) (*FinalizeWriteStreamResponse, error)
	// Deprecated: Do not use.
	// Atomically commits a group of `PENDING` streams that belong to the same
	// `parent` table.
	// Streams must be finalized before commit and cannot be committed multiple
	// times. Once a stream is committed, data in the stream becomes available
	// for read operations.
	BatchCommitWriteStreams(ctx context.Context, in *BatchCommitWriteStreamsRequest, opts ...grpc.CallOption) (*BatchCommitWriteStreamsResponse, error)
	// Deprecated: Do not use.
	// Flushes rows to a BUFFERED stream.
	// If users are appending rows to BUFFERED stream, flush operation is
	// required in order for the rows to become available for reading. A
	// Flush operation flushes up to any previously flushed offset in a BUFFERED
	// stream, to the offset specified in the request.
	// Flush is not supported on the _default stream, since it is not BUFFERED.
	FlushRows(ctx context.Context, in *FlushRowsRequest, opts ...grpc.CallOption) (*FlushRowsResponse, error)
}

func NewBigQueryWriteClient(cc grpc.ClientConnInterface) BigQueryWriteClient

type BigQueryWriteServer interface {
	// Deprecated: Do not use.
	// Creates a write stream to the given table.
	// Additionally, every table has a special COMMITTED stream named '_default'
	// to which data can be written. This stream doesn't need to be created using
	// CreateWriteStream. It is a stream that can be used simultaneously by any
	// number of clients. Data written to this stream is considered committed as
	// soon as an acknowledgement is received.
	CreateWriteStream(context.Context, *CreateWriteStreamRequest) (*WriteStream, error)
	// Deprecated: Do not use.
	// Appends data to the given stream.
	//
	// If `offset` is specified, the `offset` is checked against the end of
	// stream. The server returns `OUT_OF_RANGE` in `AppendRowsResponse` if an
	// attempt is made to append to an offset beyond the current end of the stream
	// or `ALREADY_EXISTS` if user provids an `offset` that has already been
	// written to. User can retry with adjusted offset within the same RPC
	// stream. If `offset` is not specified, append happens at the end of the
	// stream.
	//
	// The response contains the offset at which the append happened. Responses
	// are received in the same order in which requests are sent. There will be
	// one response for each successful request. If the `offset` is not set in
	// response, it means append didn't happen due to some errors. If one request
	// fails, all the subsequent requests will also fail until a success request
	// is made again.
	//
	// If the stream is of `PENDING` type, data will only be available for read
	// operations after the stream is committed.
	AppendRows(BigQueryWrite_AppendRowsServer) error
	// Deprecated: Do not use.
	// Gets a write stream.
	GetWriteStream(context.Context, *GetWriteStreamRequest) (*WriteStream, error)
	// Deprecated: Do not use.
	// Finalize a write stream so that no new data can be appended to the
	// stream. Finalize is not supported on the '_default' stream.
	FinalizeWriteStream(context.Context, *FinalizeWriteStreamRequest) (*FinalizeWriteStreamResponse, error)
	// Deprecated: Do not use.
	// Atomically commits a group of `PENDING` streams that belong to the same
	// `parent` table.
	// Streams must be finalized before commit and cannot be committed multiple
	// times. Once a stream is committed, data in the stream becomes available
	// for read operations.
	BatchCommitWriteStreams(context.Context, *BatchCommitWriteStreamsRequest) (*BatchCommitWriteStreamsResponse, error)
	// Deprecated: Do not use.
	// Flushes rows to a BUFFERED stream.
	// If users are appending rows to BUFFERED stream, flush operation is
	// required in order for the rows to become available for reading. A
	// Flush operation flushes up to any previously flushed offset in a BUFFERED
	// stream, to the offset specified in the request.
	// Flush is not supported on the _default stream, since it is not BUFFERED.
	FlushRows(context.Context, *FlushRowsRequest) (*FlushRowsResponse, error)
}

type BigQueryWrite_AppendRowsClient interface {
	Send(*AppendRowsRequest) error
	Recv() (*AppendRowsResponse, error)
	grpc.ClientStream
}

type BigQueryWrite_AppendRowsServer interface {
	Send(*AppendRowsResponse) error
	Recv() (*AppendRowsRequest, error)
	grpc.ServerStream
}

type CreateReadSessionRequest struct {

	// Required. The request project that owns the session, in the form of
	// `projects/{project_id}`.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. Session to be created.
	ReadSession *ReadSession `protobuf:"bytes,2,opt,name=read_session,json=readSession,proto3" json:"read_session,omitempty"`
	// Max initial number of streams. If unset or zero, the server will
	// provide a value of streams so as to produce reasonable throughput. Must be
	// non-negative. The number of streams may be lower than the requested number,
	// depending on the amount parallelism that is reasonable for the table. Error
	// will be returned if the max count is greater than the current system
	// max limit of 1,000.
	//
	// Streams must be read starting from offset 0.
	MaxStreamCount int32 `protobuf:"varint,3,opt,name=max_stream_count,json=maxStreamCount,proto3" json:"max_stream_count,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateReadSessionRequest) Descriptor() ([]byte, []int)

func (x *CreateReadSessionRequest) GetMaxStreamCount() int32

func (x *CreateReadSessionRequest) GetParent() string

func (x *CreateReadSessionRequest) GetReadSession() *ReadSession

func (*CreateReadSessionRequest) ProtoMessage()

func (x *CreateReadSessionRequest) ProtoReflect() protoreflect.Message

func (x *CreateReadSessionRequest) Reset()

func (x *CreateReadSessionRequest) String() string

type CreateWriteStreamRequest struct {

	// Required. Reference to the table to which the stream belongs, in the format
	// of `projects/{project}/datasets/{dataset}/tables/{table}`.
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`
	// Required. Stream to be created.
	WriteStream *WriteStream `protobuf:"bytes,2,opt,name=write_stream,json=writeStream,proto3" json:"write_stream,omitempty"`
	// contains filtered or unexported fields
}

func (*CreateWriteStreamRequest) Descriptor() ([]byte, []int)

func (x *CreateWriteStreamRequest) GetParent() string

func (x *CreateWriteStreamRequest) GetWriteStream() *WriteStream

func (*CreateWriteStreamRequest) ProtoMessage()

func (x *CreateWriteStreamRequest) ProtoReflect() protoreflect.Message

func (x *CreateWriteStreamRequest) Reset()

func (x *CreateWriteStreamRequest) String() string

type DataFormat int32

const (
	DataFormat_DATA_FORMAT_UNSPECIFIED DataFormat = 0
	// Avro is a standard open source row based file format.
	// See https://avro.apache.org/ for more details.
	DataFormat_AVRO DataFormat = 1
	// Arrow is a standard open source column-based message format.
	// See https://arrow.apache.org/ for more details.
	DataFormat_ARROW DataFormat = 2
)

func (DataFormat) Descriptor() protoreflect.EnumDescriptor

func (x DataFormat) Enum() *DataFormat

func (DataFormat) EnumDescriptor() ([]byte, []int)

func (x DataFormat) Number() protoreflect.EnumNumber

func (x DataFormat) String() string

func (DataFormat) Type() protoreflect.EnumType

type FinalizeWriteStreamRequest struct {

	// Required. Name of the stream to finalize, in the form of
	// `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*FinalizeWriteStreamRequest) Descriptor() ([]byte, []int)

func (x *FinalizeWriteStreamRequest) GetName() string

func (*FinalizeWriteStreamRequest) ProtoMessage()

func (x *FinalizeWriteStreamRequest) ProtoReflect() protoreflect.Message

func (x *FinalizeWriteStreamRequest) Reset()

func (x *FinalizeWriteStreamRequest) String() string

type FinalizeWriteStreamResponse struct {

	// Number of rows in the finalized stream.
	RowCount int64 `protobuf:"varint,1,opt,name=row_count,json=rowCount,proto3" json:"row_count,omitempty"`
	// contains filtered or unexported fields
}

func (*FinalizeWriteStreamResponse) Descriptor() ([]byte, []int)

func (x *FinalizeWriteStreamResponse) GetRowCount() int64

func (*FinalizeWriteStreamResponse) ProtoMessage()

func (x *FinalizeWriteStreamResponse) ProtoReflect() protoreflect.Message

func (x *FinalizeWriteStreamResponse) Reset()

func (x *FinalizeWriteStreamResponse) String() string

type FlushRowsRequest struct {

	// Required. The stream that is the target of the flush operation.
	WriteStream string `protobuf:"bytes,1,opt,name=write_stream,json=writeStream,proto3" json:"write_stream,omitempty"`
	// Ending offset of the flush operation. Rows before this offset(including
	// this offset) will be flushed.
	Offset *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

func (*FlushRowsRequest) Descriptor() ([]byte, []int)

func (x *FlushRowsRequest) GetOffset() *wrapperspb.Int64Value

func (x *FlushRowsRequest) GetWriteStream() string

func (*FlushRowsRequest) ProtoMessage()

func (x *FlushRowsRequest) ProtoReflect() protoreflect.Message

func (x *FlushRowsRequest) Reset()

func (x *FlushRowsRequest) String() string

type FlushRowsResponse struct {

	// The rows before this offset (including this offset) are flushed.
	Offset int64 `protobuf:"varint,1,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

func (*FlushRowsResponse) Descriptor() ([]byte, []int)

func (x *FlushRowsResponse) GetOffset() int64

func (*FlushRowsResponse) ProtoMessage()

func (x *FlushRowsResponse) ProtoReflect() protoreflect.Message

func (x *FlushRowsResponse) Reset()

func (x *FlushRowsResponse) String() string

type GetWriteStreamRequest struct {

	// Required. Name of the stream to get, in the form of
	// `projects/{project}/datasets/{dataset}/tables/{table}/streams/{stream}`.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

func (*GetWriteStreamRequest) Descriptor() ([]byte, []int)

func (x *GetWriteStreamRequest) GetName() string

func (*GetWriteStreamRequest) ProtoMessage()

func (x *GetWriteStreamRequest) ProtoReflect() protoreflect.Message

func (x *GetWriteStreamRequest) Reset()

func (x *GetWriteStreamRequest) String() string

type ProtoRows struct {

	// A sequence of rows serialized as a Protocol Buffer.
	//
	// See https://developers.google.com/protocol-buffers/docs/overview for more
	// information on deserializing this field.
	SerializedRows [][]byte `protobuf:"bytes,1,rep,name=serialized_rows,json=serializedRows,proto3" json:"serialized_rows,omitempty"`
	// contains filtered or unexported fields
}

func (*ProtoRows) Descriptor() ([]byte, []int)

func (x *ProtoRows) GetSerializedRows() [][]byte

func (*ProtoRows) ProtoMessage()

func (x *ProtoRows) ProtoReflect() protoreflect.Message

func (x *ProtoRows) Reset()

func (x *ProtoRows) String() string

type ProtoSchema struct {

	// Descriptor for input message. The descriptor has to be self contained,
	// including all the nested types, excepted for proto buffer well known types
	// (https://developers.google.com/protocol-buffers/docs/reference/google.protobuf).
	ProtoDescriptor *descriptorpb.DescriptorProto `protobuf:"bytes,1,opt,name=proto_descriptor,json=protoDescriptor,proto3" json:"proto_descriptor,omitempty"`
	// contains filtered or unexported fields
}

func (*ProtoSchema) Descriptor() ([]byte, []int)

func (x *ProtoSchema) GetProtoDescriptor() *descriptorpb.DescriptorProto

func (*ProtoSchema) ProtoMessage()

func (x *ProtoSchema) ProtoReflect() protoreflect.Message

func (x *ProtoSchema) Reset()

func (x *ProtoSchema) String() string

type ReadRowsRequest struct {

	// Required. Stream to read rows from.
	ReadStream string `protobuf:"bytes,1,opt,name=read_stream,json=readStream,proto3" json:"read_stream,omitempty"`
	// The offset requested must be less than the last row read from Read.
	// Requesting a larger offset is undefined. If not specified, start reading
	// from offset zero.
	Offset int64 `protobuf:"varint,2,opt,name=offset,proto3" json:"offset,omitempty"`
	// contains filtered or unexported fields
}

func (*ReadRowsRequest) Descriptor() ([]byte, []int)

func (x *ReadRowsRequest) GetOffset() int64

func (x *ReadRowsRequest) GetReadStream() string

func (*ReadRowsRequest) ProtoMessage()

func (x *ReadRowsRequest) ProtoReflect() protoreflect.Message

func (x *ReadRowsRequest) Reset()

func (x *ReadRowsRequest) String() string

type ReadRowsResponse struct {

	// Row data is returned in format specified during session creation.
	//
	// Types that are assignable to Rows:
	//
	//	*ReadRowsResponse_AvroRows
	//	*ReadRowsResponse_ArrowRecordBatch
	Rows isReadRowsResponse_Rows `protobuf_oneof:"rows"`
	// Number of serialized rows in the rows block.
	RowCount int64 `protobuf:"varint,6,opt,name=row_count,json=rowCount,proto3" json:"row_count,omitempty"`
	// Statistics for the stream.
	Stats *StreamStats `protobuf:"bytes,2,opt,name=stats,proto3" json:"stats,omitempty"`
	// Throttling state. If unset, the latest response still describes
	// the current throttling status.
	ThrottleState *ThrottleState `protobuf:"bytes,5,opt,name=throttle_state,json=throttleState,proto3" json:"throttle_state,omitempty"`
	// The schema for the read. If read_options.selected_fields is set, the
	// schema may be different from the table schema as it will only contain
	// the selected fields. This schema is equivalent to the one returned by
	// CreateSession. This field is only populated in the first ReadRowsResponse
	// RPC.
	//
	// Types that are assignable to Schema:
	//
	//	*ReadRowsResponse_AvroSchema
	//	*ReadRowsResponse_ArrowSchema
	Schema isReadRowsResponse_Schema `protobuf_oneof:"schema"`
	// contains filtered or unexported fields
}

func (*ReadRowsResponse) Descriptor() ([]byte, []int)

func (x *ReadRowsResponse) GetArrowRecordBatch() *ArrowRecordBatch

func (x *ReadRowsResponse) GetArrowSchema() *ArrowSchema

func (x *ReadRowsResponse) GetAvroRows() *AvroRows

func (x *ReadRowsResponse) GetAvroSchema() *AvroSchema

func (x *ReadRowsResponse) GetRowCount() int64

func (m *ReadRowsResponse) GetRows() isReadRowsResponse_Rows

func (m *ReadRowsResponse) GetSchema() isReadRowsResponse_Schema

func (x *ReadRowsResponse) GetStats() *StreamStats

func (x *ReadRowsResponse) GetThrottleState() *ThrottleState

func (*ReadRowsResponse) ProtoMessage()

func (x *ReadRowsResponse) ProtoReflect() protoreflect.Message

func (x *ReadRowsResponse) Reset()

func (x *ReadRowsResponse) String() string

type ReadRowsResponse_ArrowRecordBatch struct {
	// Serialized row data in Arrow RecordBatch format.
	ArrowRecordBatch *ArrowRecordBatch `protobuf:"bytes,4,opt,name=arrow_record_batch,json=arrowRecordBatch,proto3,oneof"`
}

type ReadRowsResponse_ArrowSchema struct {
	// Output only. Arrow schema.
	ArrowSchema *ArrowSchema `protobuf:"bytes,8,opt,name=arrow_schema,json=arrowSchema,proto3,oneof"`
}

type ReadRowsResponse_AvroRows struct {
	// Serialized row data in AVRO format.
	AvroRows *AvroRows `protobuf:"bytes,3,opt,name=avro_rows,json=avroRows,proto3,oneof"`
}

type ReadRowsResponse_AvroSchema struct {
	// Output only. Avro schema.
	AvroSchema *AvroSchema `protobuf:"bytes,7,opt,name=avro_schema,json=avroSchema,proto3,oneof"`
}

type ReadSession struct {

	// Output only. Unique identifier for the session, in the form
	// `projects/{project_id}/locations/{location}/sessions/{session_id}`.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Output only. Time at which the session becomes invalid. After this time, subsequent
	// requests to read this Session will return errors. The expire_time is
	// automatically assigned and currently cannot be specified or updated.
	ExpireTime *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=expire_time,json=expireTime,proto3" json:"expire_time,omitempty"`
	// Immutable. Data format of the output data.
	DataFormat DataFormat `protobuf:"varint,3,opt,name=data_format,json=dataFormat,proto3,enum=google.cloud.bigquery.storage.v1beta2.DataFormat" json:"data_format,omitempty"`
	// The schema for the read. If read_options.selected_fields is set, the
	// schema may be different from the table schema as it will only contain
	// the selected fields.
	//
	// Types that are assignable to Schema:
	//
	//	*ReadSession_AvroSchema
	//	*ReadSession_ArrowSchema
	Schema isReadSession_Schema `protobuf_oneof:"schema"`
	// Immutable. Table that this ReadSession is reading from, in the form
	// `projects/{project_id}/datasets/{dataset_id}/tables/{table_id}
	Table string `protobuf:"bytes,6,opt,name=table,proto3" json:"table,omitempty"`
	// Optional. Any modifiers which are applied when reading from the specified table.
	TableModifiers *ReadSession_TableModifiers `protobuf:"bytes,7,opt,name=table_modifiers,json=tableModifiers,proto3" json:"table_modifiers,omitempty"`
	// Optional. Read options for this session (e.g. column selection, filters).
	ReadOptions *ReadSession_TableReadOptions `protobuf:"bytes,8,opt,name=read_options,json=readOptions,proto3" json:"read_options,omitempty"`
	// Output only. A list of streams created with the session.
	//
	// At least one stream is created with the session. In the future, larger
	// request_stream_count values *may* result in this list being unpopulated,
	// in that case, the user will need to use a List method to get the streams
	// instead, which is not yet available.
	Streams []*ReadStream `protobuf:"bytes,10,rep,name=streams,proto3" json:"streams,omitempty"`
	// contains filtered or unexported fields
}

func (*ReadSession) Descriptor() ([]byte, []int)

func (x *ReadSession) GetArrowSchema() *ArrowSchema

func (x *ReadSession) GetAvroSchema() *AvroSchema

func (x *ReadSession) GetDataFormat() DataFormat

func (x *ReadSession) GetExpireTime() *timestamppb.Timestamp

func (x *ReadSession) GetName() string

func (x *ReadSession) GetReadOptions() *ReadSession_TableReadOptions