Package cloud.google.com/go/bigquery/storage/apiv1/storagepb (v1.50.0)

var (
	ArrowSerializationOptions_CompressionCodec_name = map[int32]string{
		0: "COMPRESSION_UNSPECIFIED",
		1: "LZ4_FRAME",
		2: "ZSTD",
	}
	ArrowSerializationOptions_CompressionCodec_value = map[string]int32{
		"COMPRESSION_UNSPECIFIED": 0,
		"LZ4_FRAME":               1,
		"ZSTD":                    2,
	}
)

var (
	AppendRowsRequest_MissingValueInterpretation_name = map[int32]string{
		0: "MISSING_VALUE_INTERPRETATION_UNSPECIFIED",
		1: "NULL_VALUE",
		2: "DEFAULT_VALUE",
	}
	AppendRowsRequest_MissingValueInterpretation_value = map[string]int32{
		"MISSING_VALUE_INTERPRETATION_UNSPECIFIED": 0,
		"NULL_VALUE":    1,
		"DEFAULT_VALUE": 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",
		7: "SCHEMA_MISMATCH_EXTRA_FIELDS",
		8: "OFFSET_ALREADY_EXISTS",
		9: "OFFSET_OUT_OF_RANGE",
	}
	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,
		"SCHEMA_MISMATCH_EXTRA_FIELDS":   7,
		"OFFSET_ALREADY_EXISTS":          8,
		"OFFSET_OUT_OF_RANGE":            9,
	}
)

var (
	RowError_RowErrorCode_name = map[int32]string{
		0: "ROW_ERROR_CODE_UNSPECIFIED",
		1: "FIELDS_ERROR",
	}
	RowError_RowErrorCode_value = map[string]int32{
		"ROW_ERROR_CODE_UNSPECIFIED": 0,
		"FIELDS_ERROR":               1,
	}
)

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 (
	WriteStreamView_name = map[int32]string{
		0: "WRITE_STREAM_VIEW_UNSPECIFIED",
		1: "BASIC",
		2: "FULL",
	}
	WriteStreamView_value = map[string]int32{
		"WRITE_STREAM_VIEW_UNSPECIFIED": 0,
		"BASIC":                         1,
		"FULL":                          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 (
	WriteStream_WriteMode_name = map[int32]string{
		0: "WRITE_MODE_UNSPECIFIED",
		1: "INSERT",
	}
	WriteStream_WriteMode_value = map[string]int32{
		"WRITE_MODE_UNSPECIFIED": 0,
		"INSERT":                 1,
	}
)

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 (
	// Setting the column_name extension allows users to reference
	// bigquery column independently of the field name in the protocol buffer
	// message.
	//
	// The intended use of this annotation is to reference a destination column
	// named using characters unavailable for protobuf field names (e.g. unicode
	// characters).
	//
	// More details about BigQuery naming limitations can be found here:
	// https://cloud.google.com/bigquery/docs/schemas#column_names
	//
	// This extension is currently experimental.
	//
	// optional string column_name = 454943157;
	E_ColumnName = &file_google_cloud_bigquery_storage_v1_annotations_proto_extTypes[0]
)

var File_google_cloud_bigquery_storage_v1_annotations_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_arrow_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_avro_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_protobuf_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_storage_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_stream_proto protoreflect.FileDescriptor

var File_google_cloud_bigquery_storage_v1_table_proto protoreflect.FileDescriptor

func RegisterBigQueryReadServer(s *grpc.Server, srv BigQueryReadServer)

func RegisterBigQueryWriteServer(s *grpc.Server, srv BigQueryWriteServer)

type AppendRowsRequest struct {
	WriteStream string `protobuf:"bytes,1,opt,name=write_stream,json=writeStream,proto3" json:"write_stream,omitempty"`

	Offset *wrapperspb.Int64Value `protobuf:"bytes,2,opt,name=offset,proto3" json:"offset,omitempty"`

	Rows isAppendRowsRequest_Rows `protobuf_oneof:"rows"`

	TraceId string `protobuf:"bytes,6,opt,name=trace_id,json=traceId,proto3" json:"trace_id,omitempty"`

	MissingValueInterpretations map[string]AppendRowsRequest_MissingValueInterpretation "" /* 316 byte string literal not displayed */

}

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

func (x *AppendRowsRequest) GetMissingValueInterpretations() map[string]AppendRowsRequest_MissingValueInterpretation

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_MissingValueInterpretation int32

const (
	// Invalid missing value interpretation. Requests with this value will be
	// rejected.
	AppendRowsRequest_MISSING_VALUE_INTERPRETATION_UNSPECIFIED AppendRowsRequest_MissingValueInterpretation = 0
	// Missing value is interpreted as NULL.
	AppendRowsRequest_NULL_VALUE AppendRowsRequest_MissingValueInterpretation = 1
	// Missing value is interpreted as column default value if declared in the
	// table schema, NULL otherwise.
	AppendRowsRequest_DEFAULT_VALUE AppendRowsRequest_MissingValueInterpretation = 2
)

func (AppendRowsRequest_MissingValueInterpretation) Descriptor() protoreflect.EnumDescriptor

func (x AppendRowsRequest_MissingValueInterpretation) Enum() *AppendRowsRequest_MissingValueInterpretation

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

func (x AppendRowsRequest_MissingValueInterpretation) Number() protoreflect.EnumNumber

func (x AppendRowsRequest_MissingValueInterpretation) String() string

func (AppendRowsRequest_MissingValueInterpretation) Type() protoreflect.EnumType

type AppendRowsRequest_ProtoData struct {

	// Proto schema used to serialize the data.  This value only needs to be
	// provided as part of the first request on a gRPC network connection,
	// and will be ignored for subsequent requests on the connection.
	WriterSchema *ProtoSchema `protobuf:"bytes,1,opt,name=writer_schema,json=writerSchema,proto3" json:"writer_schema,omitempty"`
	// Serialized row data in protobuf message format.
	// Currently, the backend expects the serialized rows to adhere to
	// proto2 semantics when appending rows, particularly with respect to
	// how default values are encoded.
	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"`
	// If a request failed due to corrupted rows, no rows in the batch will be
	// appended. The API will return row level error info, so that the caller can
	// remove the bad rows and retry the request.
	RowErrors []*RowError `protobuf:"bytes,4,rep,name=row_errors,json=rowErrors,proto3" json:"row_errors,omitempty"`
	// The target of the append operation. Matches the write_stream in the
	// corresponding request.
	WriteStream string `protobuf:"bytes,5,opt,name=write_stream,json=writeStream,proto3" json:"write_stream,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) GetRowErrors() []*RowError

func (x *AppendRowsResponse) GetUpdatedSchema() *TableSchema

func (x *AppendRowsResponse) GetWriteStream() string

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"`
	// [Deprecated] The count of rows in `serialized_record_batch`.
	// Please use the format-independent ReadRowsResponse.row_count instead.
	//
	// Deprecated: Do not use.
	RowCount int64 `protobuf:"varint,2,opt,name=row_count,json=rowCount,proto3" json:"row_count,omitempty"`
	// contains filtered or unexported fields
}

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

func (x *ArrowRecordBatch) GetRowCount() int64

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 {
	BufferCompression ArrowSerializationOptions_CompressionCodec "" /* 194 byte string literal not displayed */

}

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

func (x *ArrowSerializationOptions) GetBufferCompression() ArrowSerializationOptions_CompressionCodec

func (*ArrowSerializationOptions) ProtoMessage()

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

func (x *ArrowSerializationOptions) Reset()

func (x *ArrowSerializationOptions) String() string

type ArrowSerializationOptions_CompressionCodec int32

const (
	// If unspecified no compression will be used.
	ArrowSerializationOptions_COMPRESSION_UNSPECIFIED ArrowSerializationOptions_CompressionCodec = 0
	// LZ4 Frame (https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md)
	ArrowSerializationOptions_LZ4_FRAME ArrowSerializationOptions_CompressionCodec = 1
	// Zstandard compression.
	ArrowSerializationOptions_ZSTD ArrowSerializationOptions_CompressionCodec = 2
)

func (ArrowSerializationOptions_CompressionCodec) Descriptor() protoreflect.EnumDescriptor

func (x ArrowSerializationOptions_CompressionCodec) Enum() *ArrowSerializationOptions_CompressionCodec

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

func (x ArrowSerializationOptions_CompressionCodec) Number() protoreflect.EnumNumber

func (x ArrowSerializationOptions_CompressionCodec) String() string

func (ArrowSerializationOptions_CompressionCodec) 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"`
	// [Deprecated] The count of rows in the returning block.
	// Please use the format-independent ReadRowsResponse.row_count instead.
	//
	// Deprecated: Do not use.
	RowCount int64 `protobuf:"varint,2,opt,name=row_count,json=rowCount,proto3" json:"row_count,omitempty"`
	// contains filtered or unexported fields
}

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

func (x *AvroRows) GetRowCount() int64

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 AvroSerializationOptions struct {
	EnableDisplayNameAttribute bool "" /* 144 byte string literal not displayed */

}

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

func (x *AvroSerializationOptions) GetEnableDisplayNameAttribute() bool

func (*AvroSerializationOptions) ProtoMessage()

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

func (x *AvroSerializationOptions) Reset()

func (x *AvroSerializationOptions) 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 {
	// Creates a write stream to the given table.
	// Additionally, every table has a special 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)
	// 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 provides an `offset` that has already been
	// written to. User can retry with adjusted offset within the same RPC
	// connection. If `offset` is not specified, append happens at the end of the
	// stream.
	//
	// The response contains an optional offset at which the append
	// happened.  No offset information will be returned for appends to a
	// default stream.
	//
	// Responses are received in the same order in which requests are sent.
	// There will be one response for each successful inserted request.  Responses
	// may optionally embed error information if the originating AppendRequest was
	// not successfully processed.
	//
	// The specifics of when successfully appended data is made visible to the
	// table are governed by the type of stream:
	//
	// * For COMMITTED streams (which includes the default stream), data is
	// visible immediately upon successful append.
	//
	// * For BUFFERED streams, data is made visible via a subsequent `FlushRows`
	// rpc which advances a cursor to a newer offset in the stream.
	//
	// * For PENDING streams, data is not made visible until the stream itself is
	// finalized (via the `FinalizeWriteStream` rpc), and the stream is explicitly
	// committed via the `BatchCommitWriteStreams` rpc.
	AppendRows(ctx context.Context, opts ...grpc.CallOption) (BigQueryWrite_AppendRowsClient, error)
	// Gets information about a write stream.
	GetWriteStream(ctx context.Context, in *GetWriteStreamRequest, opts ...grpc.CallOption) (*WriteStream, error)
	// 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)
	// 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)
	// 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 {
	// Creates a write stream to the given table.
	// Additionally, every table has a special 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)
	// 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 provides an `offset` that has already been
	// written to. User can retry with adjusted offset within the same RPC
	// connection. If `offset` is not specified, append happens at the end of the
	// stream.
	//
	// The response contains an optional offset at which the append
	// happened.  No offset information will be returned for appends to a
	// default stream.
	//
	// Responses are received in the same order in which requests are sent.
	// There will be one response for each successful inserted request.  Responses
	// may optionally embed error information if the originating AppendRequest was
	// not successfully processed.
	//
	// The specifics of when successfully appended data is made visible to the
	// table are governed by the type of stream:
	//
	// * For COMMITTED streams (which includes the default stream), data is
	// visible immediately upon successful append.
	//
	// * For BUFFERED streams, data is made visible via a subsequent `FlushRows`
	// rpc which advances a cursor to a newer offset in the stream.
	//
	// * For PENDING streams, data is not made visible until the stream itself is
	// finalized (via the `FinalizeWriteStream` rpc), and the stream is explicitly
	// committed via the `BatchCommitWriteStreams` rpc.
	AppendRows(BigQueryWrite_AppendRowsServer) error
	// Gets information about a write stream.
	GetWriteStream(context.Context, *GetWriteStreamRequest) (*WriteStream, error)
	// 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)
	// 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)
	// 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 {
	Parent string `protobuf:"bytes,1,opt,name=parent,proto3" json:"parent,omitempty"`

	ReadSession *ReadSession `protobuf:"bytes,2,opt,name=read_session,json=readSession,proto3" json:"read_session,omitempty"`

	MaxStreamCount int32 `protobuf:"varint,3,opt,name=max_stream_count,json=maxStreamCount,proto3" json:"max_stream_count,omitempty"`

	PreferredMinStreamCount int32 "" /* 135 byte string literal not displayed */

}

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

func (x *CreateReadSessionRequest) GetMaxStreamCount() int32

func (x *CreateReadSessionRequest) GetParent() string

func (x *CreateReadSessionRequest) GetPreferredMinStreamCount() int32

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 (
	// Data format is unspecified.
	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"`
	// Indicates whether to get full or partial view of the WriteStream. If
	// not set, view returned will be basic.
	View WriteStreamView `protobuf:"varint,3,opt,name=view,proto3,enum=google.cloud.bigquery.storage.v1.WriteStreamView" json:"view,omitempty"`
	// contains filtered or unexported fields
}

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

func (x *GetWriteStreamRequest) GetName() string

func (x *GetWriteStreamRequest) GetView() WriteStreamView

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 provided descriptor must be self
	// contained, such that data rows sent can be fully decoded using only the
	// single descriptor.  For data rows that are compositions of multiple
	// independent messages, this means the descriptor may need to be transformed
	// to only use nested types:
	// https://developers.google.com/protocol-buffers/docs/proto#nested
	//
	// For additional information for how proto types and values map onto BigQuery
	// see: https://cloud.google.com/bigquery/docs/write-api#data_type_conversions
	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