{ "fullyEncodeReservedExpansion": true, "documentationLink": "https://cloud.google.com/bigtable/", "schemas": { "GoogleBigtableV2..ColumnRange": { "description": "Specifies a contiguous range of columns within a single column family. The range spans from \u003ccolumn_family\u003e:\u003cstart_qualifier\u003e to \u003ccolumn_family\u003e:\u003cend_qualifier\u003e, where both bounds can be either inclusive or exclusive.", "id": "GoogleBigtableV2..ColumnRange", "type": "object", "properties": { "familyName": { "description": "The name of the column family within which this range falls.", "type": "string" }, "endQualifierClosed": { "type": "string", "description": "Used when giving an inclusive upper bound for the range.", "format": "byte" }, "endQualifierOpen": { "type": "string", "description": "Used when giving an exclusive upper bound for the range.", "format": "byte" }, "startQualifierClosed": { "description": "Used when giving an inclusive lower bound for the range.", "type": "string", "format": "byte" }, "startQualifierOpen": { "description": "Used when giving an exclusive lower bound for the range.", "type": "string", "format": "byte" } } }, "GoogleBigtableV2..SessionReadRowRequest": { "id": "GoogleBigtableV2..SessionReadRowRequest", "type": "object", "properties": { "key": { "format": "byte", "type": "string" }, "filter": { "$ref": "GoogleBigtableV2..RowFilter" } }, "description": "Internal usage only." }, "GoogleBigtableV2..Mutation": { "description": "Specifies a particular change to be made to the contents of a row.", "type": "object", "properties": { "timestampOrigin": { "enum": [ "TIMESTAMP_ORIGIN_UNSPECIFIED", "USER_SPECIFIED", "CLIENT_AUTO_GENERATED" ], "description": "Optional. The origin of the timestamp in this mutation.", "type": "string", "enumDescriptions": [ "Default value. Should not be explicitly set.", "Indicates that the timestamp was explicitly provided by the user (either `\u003e0` or `-1` for server-assigned). The server will reject the mutation if the timestamp's precision does not match the table's granularity. (e.g., a millisecond table only allows timestamps that are multiples of 1000).", "Indicates that the timestamp was auto-generated by the client library. The server will truncate the timestamp's precision to match the table's granularity. (e.g., zeroing the last 3 digits for a millisecond table)." ] }, "setCell": { "$ref": "GoogleBigtableV2.Mutation.SetCell", "description": "Set a cell's value." }, "mergeToCell": { "$ref": "GoogleBigtableV2.Mutation.MergeToCell", "description": "Merges accumulated state to an `Aggregate` cell." }, "addToCell": { "$ref": "GoogleBigtableV2.Mutation.AddToCell", "description": "Incrementally updates an `Aggregate` cell." }, "deleteFromRow": { "$ref": "GoogleBigtableV2.Mutation.DeleteFromRow", "description": "Deletes cells from the entire row." }, "deleteFromColumn": { "$ref": "GoogleBigtableV2.Mutation.DeleteFromColumn", "description": "Deletes cells from a column." }, "deleteFromFamily": { "description": "Deletes cells from a column family.", "$ref": "GoogleBigtableV2.Mutation.DeleteFromFamily" } }, "id": "GoogleBigtableV2..Mutation" }, "GoogleBigtableV2..ReadChangeStreamResponse": { "properties": { "closeStream": { "$ref": "GoogleBigtableV2.ReadChangeStreamResponse.CloseStream", "description": "An indication that the stream should be closed." }, "dataChange": { "description": "A mutation to the partition.", "$ref": "GoogleBigtableV2.ReadChangeStreamResponse.DataChange" }, "heartbeat": { "description": "A periodic heartbeat message.", "$ref": "GoogleBigtableV2.ReadChangeStreamResponse.Heartbeat" } }, "type": "object", "id": "GoogleBigtableV2..ReadChangeStreamResponse", "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. Response message for Bigtable.ReadChangeStream." }, "GoogleBigtableV2..AuthorizedViewResponse": { "id": "GoogleBigtableV2..AuthorizedViewResponse", "properties": { "mutateRow": { "$ref": "GoogleBigtableV2..SessionMutateRowResponse" }, "mutateRows": { "$ref": "GoogleBigtableV2..SessionMutateRowsResponse" }, "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowResponse" }, "readModifyWriteRow": { "$ref": "GoogleBigtableV2..SessionReadModifyWriteRowResponse" }, "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsResponse" }, "checkAndMutateRow": { "$ref": "GoogleBigtableV2..SessionCheckAndMutateRowResponse" } }, "description": "A response wrapper for operations on an authorized view. Internal usage only.", "type": "object" }, "GoogleBigtableV2..RowRange": { "type": "object", "description": "Specifies a contiguous range of rows.", "id": "GoogleBigtableV2..RowRange", "properties": { "endKeyOpen": { "type": "string", "description": "Used when giving an exclusive upper bound for the range.", "format": "byte" }, "startKeyOpen": { "description": "Used when giving an exclusive lower bound for the range.", "type": "string", "format": "byte" }, "startKeyClosed": { "format": "byte", "description": "Used when giving an inclusive lower bound for the range.", "type": "string" }, "endKeyClosed": { "type": "string", "description": "Used when giving an inclusive upper bound for the range.", "format": "byte" } } }, "GoogleBigtableV2.Mutation.DeleteFromColumn": { "description": "A Mutation which deletes cells from the specified column, optionally restricting the deletions to a given timestamp range.", "type": "object", "properties": { "familyName": { "type": "string", "description": "The name of the family from which cells should be deleted. Must match `[-_.a-zA-Z0-9]+`" }, "columnQualifier": { "description": "The qualifier of the column from which cells should be deleted. Can be any byte string, including the empty string.", "format": "byte", "type": "string" }, "timeRange": { "$ref": "GoogleBigtableV2..TimestampRange", "description": "The range of timestamps within which cells should be deleted." } }, "id": "GoogleBigtableV2.Mutation.DeleteFromColumn" }, "GoogleBigtableV2.ReadChangeStreamResponse.CloseStream": { "properties": { "status": { "$ref": "GoogleRpc..Status", "description": "The status of the stream." }, "newPartitions": { "type": "array", "description": "If non-empty, contains the new partitions to start reading from, which are related to but not necessarily identical to the partitions for the above `continuation_tokens`.", "items": { "$ref": "GoogleBigtableV2..StreamPartition" } }, "continuationTokens": { "type": "array", "description": "If non-empty, contains the information needed to resume reading their associated partitions.", "items": { "$ref": "GoogleBigtableV2..StreamContinuationToken" } } }, "description": "A message indicating that the client should stop reading from the stream. If status is OK and `continuation_tokens` & `new_partitions` are empty, the stream has finished (for example if there was an `end_time` specified). If `continuation_tokens` & `new_partitions` are present, then a change in partitioning requires the client to open a new stream for each token to resume reading. Example: [B, D) ends | v new_partitions: [A, C) [C, E) continuation_tokens.partitions: [B,C) [C,D) ^---^ ^---^ ^ ^ | | | StreamContinuationToken 2 | StreamContinuationToken 1 To read the new partition [A,C), supply the continuation tokens whose ranges cover the new partition, for example ContinuationToken[A,B) & ContinuationToken[B,C).", "id": "GoogleBigtableV2.ReadChangeStreamResponse.CloseStream", "type": "object" }, "GoogleBigtableV2..StreamContinuationTokens": { "id": "GoogleBigtableV2..StreamContinuationTokens", "properties": { "tokens": { "description": "List of continuation tokens.", "items": { "$ref": "GoogleBigtableV2..StreamContinuationToken" }, "type": "array" } }, "type": "object", "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. The information required to continue reading the data from multiple `StreamPartitions` from where a previous read left off." }, "GoogleBigtableV2..ReadIterationStats": { "description": "ReadIterationStats captures information about the iteration of rows or cells over the course of a read, e.g. how many results were scanned in a read operation versus the results returned.", "type": "object", "properties": { "cellsSeenCount": { "type": "string", "description": "The cells seen (scanned) as part of the request. This includes the count of cells returned, as captured below.", "format": "int64" }, "rowsSeenCount": { "description": "The rows seen (scanned) as part of the request. This includes the count of rows returned, as captured below.", "type": "string", "format": "int64" }, "cellsReturnedCount": { "type": "string", "description": "The cells returned as part of the request.", "format": "int64" }, "memoryLayerStats": { "description": "Statistics about the memory layer for this read.", "$ref": "GoogleBigtableV2.ReadIterationStats.MemoryLayerStats" }, "rowsReturnedCount": { "description": "The rows returned as part of the request.", "type": "string", "format": "int64" } }, "id": "GoogleBigtableV2..ReadIterationStats" }, "GoogleBigtableV2..Family": { "properties": { "columns": { "description": "Must not be empty. Sorted in order of increasing \"qualifier\".", "items": { "$ref": "GoogleBigtableV2..Column" }, "type": "array" }, "name": { "type": "string", "description": "The unique key which identifies this family within its row. This is the same key that's used to identify the family in, for example, a RowFilter which sets its \"family_name_regex_filter\" field. Must match `[-_.a-zA-Z0-9]+`, except that AggregatingRowProcessors may produce cells in a sentinel family with an empty name. Must be no greater than 64 characters in length." } }, "type": "object", "id": "GoogleBigtableV2..Family", "description": "Specifies (some of) the contents of a single row/column family intersection of a table." }, "GoogleBigtableV2.RowFilter.Chain": { "type": "object", "id": "GoogleBigtableV2.RowFilter.Chain", "properties": { "filters": { "items": { "$ref": "GoogleBigtableV2..RowFilter" }, "type": "array", "description": "The elements of \"filters\" are chained together to process the input row: in row -\u003e f(0) -\u003e intermediate row -\u003e f(1) -\u003e ... -\u003e f(N) -\u003e out row The full chain is executed atomically." } }, "description": "A RowFilter which sends rows through several RowFilters in sequence." }, "GoogleBigtableV2..ProtoRowsBatch": { "description": "A part of a serialized `ProtoRows` message.", "type": "object", "properties": { "batchData": { "format": "byte", "type": "string", "description": "Part of a serialized `ProtoRows` message. A complete, parseable ProtoRows message is constructed by concatenating `batch_data` from multiple `ProtoRowsBatch` messages. The `PartialResultSet` that contains the last part has `complete_batch` set to `true`." } }, "id": "GoogleBigtableV2..ProtoRowsBatch" }, "GoogleBigtableV2..StreamPartition": { "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. A partition of a change stream.", "id": "GoogleBigtableV2..StreamPartition", "properties": { "rowRange": { "$ref": "GoogleBigtableV2..RowRange", "description": "The row range covered by this partition and is specified by [`start_key_closed`, `end_key_open`)." } }, "type": "object" }, "GoogleBigtableV2.Type.Int32": { "id": "GoogleBigtableV2.Type.Int32", "description": "Int32 Values of type `Int32` are stored in `Value.int_value`.", "properties": { "encoding": { "$ref": "GoogleBigtableV2.TypeInt32.Encoding", "description": "The encoding to use when converting to or from lower level types." } }, "type": "object" }, "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsRequest": { "type": "object", "properties": { "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used. Single cluster routing must be configured on the profile.", "type": "string" } }, "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. Request message for Bigtable.GenerateInitialChangeStreamPartitions.", "id": "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsRequest" }, "GoogleBigtableV2.Mutation.AddToCell": { "type": "object", "description": "A Mutation which incrementally updates a cell in an `Aggregate` family.", "id": "GoogleBigtableV2.Mutation.AddToCell", "properties": { "columnQualifier": { "$ref": "GoogleBigtableV2..Value", "description": "The qualifier of the column into which new data should be added. This must be a `raw_value`." }, "timestamp": { "description": "The timestamp of the cell to which new data should be added. This must be a `raw_timestamp_micros` that matches the table's `granularity`.", "$ref": "GoogleBigtableV2..Value" }, "familyName": { "type": "string", "description": "The name of the `Aggregate` family into which new data should be added. This must be a family with a `value_type` of `Aggregate`. Format: `[-_.a-zA-Z0-9]+`" }, "input": { "$ref": "GoogleBigtableV2..Value", "description": "The input value to be accumulated into the specified cell. This must be compatible with the family's `value_type.input_type`." } } }, "GoogleBigtableV2.Type.String": { "properties": { "encoding": { "description": "The encoding to use when converting to or from lower level types.", "$ref": "GoogleBigtableV2.TypeString.Encoding" } }, "id": "GoogleBigtableV2.Type.String", "type": "object", "description": "String Values of type `String` are stored in `Value.string_value`." }, "GoogleBigtableV2..MaterializedViewResponse": { "properties": { "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowResponse" }, "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsResponse" } }, "id": "GoogleBigtableV2..MaterializedViewResponse", "description": "A response wrapper for operations on a materialized view. Internal usage only.", "type": "object" }, "GoogleBigtableV2..Idempotency": { "properties": { "startTime": { "format": "google-datetime", "type": "string", "description": "Client-assigned timestamp when the mutation's first attempt was sent. Used to reject mutations that arrive after idempotency protection may have expired. May cause spurious rejections if clock skew is too high. Leave unset or zero to always accept the mutation, at the risk of double counting if the protection for previous attempts has expired." }, "token": { "type": "string", "description": "Unique token used to identify replays of this mutation. Must be at least 8 bytes long.", "format": "byte" } }, "description": "Parameters on mutations where clients want to ensure idempotency (i.e. at-most-once semantics). This is currently only needed for certain aggregate types.", "type": "object", "id": "GoogleBigtableV2..Idempotency" }, "GoogleBigtableV2.ReadChangeStreamResponse.DataChange": { "id": "GoogleBigtableV2.ReadChangeStreamResponse.DataChange", "description": "A message corresponding to one or more mutations to the partition being streamed. A single logical `DataChange` message may also be split across a sequence of multiple individual messages. Messages other than the first in a sequence will only have the `type` and `chunks` fields populated, with the final message in the sequence also containing `done` set to true.", "type": "object", "properties": { "commitTimestamp": { "description": "The timestamp at which the mutation was applied on the Bigtable server.", "format": "google-datetime", "type": "string" }, "chunks": { "description": "The mutations associated with this change to the partition. May contain complete mutations or chunks of a multi-message chunked `DataChange` record.", "items": { "$ref": "GoogleBigtableV2.ReadChangeStreamResponse.MutationChunk" }, "type": "array" }, "done": { "description": "When true, indicates that the entire `DataChange` has been read and the client can safely process the message.", "type": "boolean" }, "rowKey": { "format": "byte", "type": "string", "description": "The row key for all mutations that are part of this `DataChange`. If the `DataChange` is chunked across multiple messages, then this field will only be set for the first message." }, "token": { "description": "An encoded position for this stream's partition to restart reading from. This token is for the StreamPartition from the request.", "type": "string" }, "type": { "description": "The type of the mutation.", "type": "string", "enumDescriptions": [ "The type is unspecified.", "A user-initiated mutation.", "A system-initiated mutation as part of garbage collection. https://cloud.google.com/bigtable/docs/garbage-collection", "This is a continuation of a multi-message change." ], "enum": [ "TYPE_UNSPECIFIED", "USER", "GARBAGE_COLLECTION", "CONTINUATION" ] }, "sourceClusterId": { "description": "The cluster where the mutation was applied. Not set when `type` is `GARBAGE_COLLECTION`.", "type": "string" }, "tiebreaker": { "type": "integer", "description": "A value that lets stream consumers reconstruct Bigtable's conflict resolution semantics. https://cloud.google.com/bigtable/docs/writes#conflict-resolution In the event that the same row key, column family, column qualifier, timestamp are modified on different clusters at the same `commit_timestamp`, the mutation with the larger `tiebreaker` will be the one chosen for the eventually consistent state of the system.", "format": "int32" }, "estimatedLowWatermark": { "format": "google-datetime", "type": "string", "description": "An estimate of the commit timestamp that is usually lower than or equal to any timestamp for a record that will be delivered in the future on the stream. It is possible that, under particular circumstances that a future record has a timestamp that is lower than a previously seen timestamp. For an example usage see https://beam.apache.org/documentation/basics/#watermarks" } } }, "GoogleBigtableV2.SessionMutateRowsResponse.RateLimitInfo": { "properties": { "period": { "type": "string", "description": "Time that must pass before the client should adjust its rate again.", "format": "google-duration" }, "factor": { "description": "Multiplier that the client should apply to its current request rate.", "format": "double", "type": "number" } }, "id": "GoogleBigtableV2.SessionMutateRowsResponse.RateLimitInfo", "type": "object", "description": "Rate limiting information for batched mutations." }, "GoogleBigtableV2.TypeTimestamp.Encoding": { "description": "Rules used to convert to or from lower level types.", "type": "object", "id": "GoogleBigtableV2.TypeTimestamp.Encoding", "properties": { "unixMicrosInt64": { "$ref": "GoogleBigtableV2.TypeInt64.Encoding", "description": "Encodes the number of microseconds since the Unix epoch using the given `Int64` encoding. Values must be microsecond-aligned. Compatible with: - Java `Instant.truncatedTo()` with `ChronoUnit.MICROS`" } } }, "GoogleBigtableV2..AuthorizedViewRequest": { "id": "GoogleBigtableV2..AuthorizedViewRequest", "properties": { "checkAndMutateRow": { "$ref": "GoogleBigtableV2..SessionCheckAndMutateRowRequest" }, "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsRequest" }, "mutateRows": { "$ref": "GoogleBigtableV2..SessionMutateRowsRequest" }, "readModifyWriteRow": { "$ref": "GoogleBigtableV2..SessionReadModifyWriteRowRequest" }, "mutateRow": { "$ref": "GoogleBigtableV2..SessionMutateRowRequest" }, "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowRequest" } }, "description": "A request wrapper for operations on an authorized view. Internal usage only.", "type": "object" }, "GoogleBigtableV2..SessionMutateRowsResponse": { "description": "Internal usage only.", "properties": { "rateLimitInfo": { "$ref": "GoogleBigtableV2.SessionMutateRowsResponse.RateLimitInfo", "description": "Information about how the client should adjust its rate of requests." }, "entries": { "description": "One or more results for Entries from the batch request.", "items": { "$ref": "GoogleBigtableV2.SessionMutateRowsResponse.Entry" }, "type": "array" } }, "type": "object", "id": "GoogleBigtableV2..SessionMutateRowsResponse" }, "GoogleBigtableV2..StreamContinuationToken": { "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. The information required to continue reading the data from a `StreamPartition` from where a previous read left off.", "properties": { "partition": { "description": "The partition that this token applies to.", "$ref": "GoogleBigtableV2..StreamPartition" }, "token": { "description": "An encoded position in the stream to restart reading from.", "type": "string" } }, "type": "object", "id": "GoogleBigtableV2..StreamContinuationToken" }, "GoogleBigtableV2..ColumnMetadata": { "description": "Describes a column in a Bigtable Query Language result set.", "type": "object", "id": "GoogleBigtableV2..ColumnMetadata", "properties": { "name": { "description": "The name of the column.", "type": "string" }, "type": { "$ref": "GoogleBigtableV2..Type", "description": "The type of the column." } } }, "GoogleType..Date": { "description": "Represents a whole or partial calendar date, such as a birthday. The time of day and time zone are either specified elsewhere or are insignificant. The date is relative to the Gregorian Calendar. This can represent one of the following: * A full date, with non-zero year, month, and day values. * A month and day, with a zero year (for example, an anniversary). * A year on its own, with a zero month and a zero day. * A year and month, with a zero day (for example, a credit card expiration date). Related types: * google.type.TimeOfDay * google.type.DateTime * google.protobuf.Timestamp", "type": "object", "id": "GoogleType..Date", "properties": { "day": { "type": "integer", "format": "int32", "description": "Day of a month. Must be from 1 to 31 and valid for the year and month, or 0 to specify a year by itself or a year and month where the day isn't significant." }, "month": { "type": "integer", "format": "int32", "description": "Month of a year. Must be from 1 to 12, or 0 to specify a year without a month and day." }, "year": { "description": "Year of the date. Must be from 1 to 9999, or 0 to specify a date without a year.", "format": "int32", "type": "integer" } } }, "GoogleBigtableV2..PeerInfo": { "id": "GoogleBigtableV2..PeerInfo", "properties": { "applicationFrontendZone": { "type": "string", "deprecated": true, "description": "The Cloud zone of the application frontend that served this request." }, "googleFrontendId": { "description": "An opaque identifier for the Google Frontend which serviced this request. Only set when not using DirectAccess.", "format": "int64", "type": "string" }, "applicationFrontendRegion": { "type": "string", "description": "The Cloud region of the application frontend that served this request." }, "applicationFrontendSubzone": { "description": "The subzone of the application frontend that served this request, e.g. an identifier for where within a zone (within the reported region) the application frontend is.", "type": "string" }, "applicationFrontendId": { "description": "An opaque identifier for the application frontend which serviced this request.", "type": "string", "format": "int64" }, "transportType": { "enum": [ "TRANSPORT_TYPE_UNKNOWN", "TRANSPORT_TYPE_EXTERNAL", "TRANSPORT_TYPE_CLOUD_PATH", "TRANSPORT_TYPE_DIRECT_ACCESS", "TRANSPORT_TYPE_SESSION_UNKNOWN", "TRANSPORT_TYPE_SESSION_EXTERNAL", "TRANSPORT_TYPE_SESSION_CLOUD_PATH", "TRANSPORT_TYPE_SESSION_DIRECT_ACCESS" ], "type": "string", "enumDescriptions": [ "The transport type is unknown.", "The client connected to this peer via an external network (e.g. outside Google Cloud).", "The client connected to this peer via CloudPath.", "The client connected to this peer via DirectAccess.", "The client connected to this peer via Bigtable Sessions using an unknown transport type.", "The client connected to this peer via Bigtable Sessions on an external network (e.g. outside Google Cloud).", "The client connected to this peer via Bigtable Sessions using CloudPath.", "The client connected to this peer via Bigtable Sessions using DirectAccess." ] } }, "description": "PeerInfo contains information about the peer that the client is connecting to.", "type": "object" }, "GoogleBigtableV2..SessionReadRowResponse": { "id": "GoogleBigtableV2..SessionReadRowResponse", "properties": { "stats": { "$ref": "GoogleBigtableV2..RequestStats" }, "row": { "$ref": "GoogleBigtableV2..Row" } }, "description": "Internal usage only.", "type": "object" }, "GoogleBigtableV2.Mutation.SetCell": { "properties": { "columnQualifier": { "format": "byte", "description": "The qualifier of the column into which new data should be written. Can be any byte string, including the empty string.", "type": "string" }, "timestampMicros": { "type": "string", "description": "The timestamp of the cell into which new data should be written. Use -1 for current Bigtable server time. Otherwise, the client should set this value itself, noting that the default value is a timestamp of zero if the field is left unspecified. Values must match the granularity of the table (e.g. micros, millis).", "format": "int64" }, "familyName": { "type": "string", "description": "The name of the family into which new data should be written. Must match `[-_.a-zA-Z0-9]+`" }, "value": { "format": "byte", "type": "string", "description": "The value to be written into the specified cell." } }, "description": "A Mutation which sets the value of the specified cell.", "type": "object", "id": "GoogleBigtableV2.Mutation.SetCell" }, "GoogleBigtableV2..Value": { "id": "GoogleBigtableV2..Value", "description": "`Value` represents a dynamically typed value. The typed fields in `Value` are used as a transport encoding for the actual value (which may be of a more complex type). See the documentation of the `Type` message for more details.", "type": "object", "properties": { "rawValue": { "description": "Represents a raw byte sequence with no type information. The `type` field must be omitted.", "format": "byte", "type": "string" }, "stringValue": { "type": "string", "description": "Represents a typed value transported as a string." }, "intValue": { "description": "Represents a typed value transported as an integer.", "format": "int64", "type": "string" }, "floatValue": { "type": "number", "description": "Represents a typed value transported as a floating point number. Does not support NaN or infinities.", "format": "double" }, "boolValue": { "description": "Represents a typed value transported as a boolean.", "type": "boolean" }, "timestampValue": { "type": "string", "format": "google-datetime", "description": "Represents a typed value transported as a timestamp." }, "arrayValue": { "$ref": "GoogleBigtableV2..ArrayValue", "description": "Represents a typed value transported as a sequence of values. To differentiate between `Struct`, `Array`, and `Map`, the outermost `Value` must provide an explicit `type` on write. This `type` will apply recursively to the nested `Struct` fields, `Array` elements, or `Map` key/value pairs, which *must not* supply their own `type`." }, "dateValue": { "description": "Represents a typed value transported as a date.", "$ref": "GoogleType..Date" }, "bytesValue": { "description": "Represents a typed value transported as a byte sequence.", "type": "string", "format": "byte" }, "rawTimestampMicros": { "type": "string", "format": "int64", "description": "Represents a raw cell timestamp with no type information. The `type` field must be omitted." }, "type": { "$ref": "GoogleBigtableV2..Type", "description": "The verified `Type` of this `Value`, if it cannot be inferred. Read results will never specify the encoding for `type` since the value will already have been decoded by the server. Furthermore, the `type` will be omitted entirely if it can be inferred from a previous response. The exact semantics for inferring `type` will vary, and are therefore documented separately for each read method. When using composite types (Struct, Array, Map) only the outermost `Value` will specify the `type`. This top-level `type` will define the types for any nested `Struct' fields, `Array` elements, or `Map` key/value pairs. If a nested `Value` provides a `type` on write, the request will be rejected with INVALID_ARGUMENT." } } }, "GoogleBigtableV2..OpenTableResponse": { "properties": {}, "id": "GoogleBigtableV2..OpenTableResponse", "description": "Internal usage only.", "type": "object" }, "GoogleBigtableV2..ResultSetMetadata": { "properties": { "protoSchema": { "$ref": "GoogleBigtableV2..ProtoSchema", "description": "Schema in proto format" } }, "id": "GoogleBigtableV2..ResultSetMetadata", "description": "Describes the structure of a Bigtable result set.", "type": "object" }, "GoogleBigtableV2.TypeAggregate.Max": { "description": "Computes the max of the input values. Allowed input: `Int64` State: same as input", "id": "GoogleBigtableV2.TypeAggregate.Max", "type": "object", "properties": {} }, "GoogleBigtableV2.RowFilter.Interleave": { "properties": { "filters": { "type": "array", "description": "The elements of \"filters\" all process a copy of the input row, and the results are pooled, sorted, and combined into a single output row. If multiple cells are produced with the same column and timestamp, they will all appear in the output row in an unspecified mutual order. Consider the following example, with three filters: input row | ----------------------------------------------------- | | | f(0) f(1) f(2) | | | 1: foo,bar,10,x foo,bar,10,z far,bar,7,a 2: foo,blah,11,z far,blah,5,x far,blah,5,x | | | ----------------------------------------------------- | 1: foo,bar,10,z // could have switched with #2 2: foo,bar,10,x // could have switched with #1 3: foo,blah,11,z 4: far,bar,7,a 5: far,blah,5,x // identical to #6 6: far,blah,5,x // identical to #5 All interleaved filters are executed atomically.", "items": { "$ref": "GoogleBigtableV2..RowFilter" } } }, "id": "GoogleBigtableV2.RowFilter.Interleave", "description": "A RowFilter which sends each row to each of several component RowFilters and interleaves the results.", "type": "object" }, "GoogleBigtableV2..MutateRowsRequest": { "properties": { "entries": { "type": "array", "description": "Required. The row keys and corresponding mutations to be applied in bulk. Each entry is applied as an atomic mutation, but the entries may be applied in arbitrary order (even between entries for the same row). At least one entry must be specified, and in total the entries can contain at most 100000 mutations.", "items": { "$ref": "GoogleBigtableV2.MutateRowsRequest.Entry" } }, "appProfileId": { "type": "string", "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used." }, "tableName": { "description": "Optional. The unique name of the table to which the mutations should be applied. Values are of the form `projects//instances//tables/`.", "type": "string" }, "authorizedViewName": { "description": "Optional. The unique name of the AuthorizedView to which the mutations should be applied. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "type": "string" } }, "id": "GoogleBigtableV2..MutateRowsRequest", "type": "object", "description": "Request message for BigtableService.MutateRows." }, "GoogleBigtableV2..ReadModifyWriteRule": { "type": "object", "id": "GoogleBigtableV2..ReadModifyWriteRule", "description": "Specifies an atomic read/modify/write operation on the latest value of the specified column.", "properties": { "familyName": { "description": "The name of the family to which the read/modify/write should be applied. Must match `[-_.a-zA-Z0-9]+`", "type": "string" }, "appendValue": { "format": "byte", "description": "Rule specifying that `append_value` be appended to the existing value. If the targeted cell is unset, it will be treated as containing the empty string.", "type": "string" }, "columnQualifier": { "format": "byte", "type": "string", "description": "The qualifier of the column to which the read/modify/write should be applied. Can be any byte string, including the empty string." }, "incrementAmount": { "type": "string", "description": "Rule specifying that `increment_amount` be added to the existing value. If the targeted cell is unset, it will be treated as containing a zero. Otherwise, the targeted cell must contain an 8-byte value (interpreted as a 64-bit big-endian signed integer), or the entire request will fail.", "format": "int64" } } }, "GoogleBigtableV2.RowFilter.Condition": { "type": "object", "properties": { "trueFilter": { "$ref": "GoogleBigtableV2..RowFilter", "description": "The filter to apply to the input row if `predicate_filter` returns any results. If not provided, no results will be returned in the true case." }, "predicateFilter": { "$ref": "GoogleBigtableV2..RowFilter", "description": "If `predicate_filter` outputs any cells, then `true_filter` will be evaluated on the input row. Otherwise, `false_filter` will be evaluated." }, "falseFilter": { "$ref": "GoogleBigtableV2..RowFilter", "description": "The filter to apply to the input row if `predicate_filter` does not return any results. If not provided, no results will be returned in the false case." } }, "id": "GoogleBigtableV2.RowFilter.Condition", "description": "A RowFilter which evaluates one of two possible RowFilters, depending on whether or not a predicate RowFilter outputs any cells from the input row. IMPORTANT NOTE: The predicate filter does not execute atomically with the true and false filters, which may lead to inconsistent or unexpected results. Additionally, Condition filters have poor performance, especially when filters are set for the false condition." }, "GoogleBigtableV2..MutateRowRequest": { "type": "object", "properties": { "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "type": "string" }, "idempotency": { "$ref": "GoogleBigtableV2..Idempotency", "description": "If set consistently across retries, prevents this mutation from being double applied to aggregate column families within a 15m window." }, "authorizedViewName": { "description": "Optional. The unique name of the AuthorizedView to which the mutation should be applied. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "type": "string" }, "mutations": { "items": { "$ref": "GoogleBigtableV2..Mutation" }, "type": "array", "description": "Required. Changes to be atomically applied to the specified row. Entries are applied in order, meaning that earlier mutations can be masked by later ones. Must contain at least one entry and at most 100000." }, "rowKey": { "type": "string", "format": "byte", "description": "Required. The key of the row to which the mutation should be applied." }, "tableName": { "type": "string", "description": "Optional. The unique name of the table to which the mutation should be applied. Values are of the form `projects//instances//tables/`." } }, "description": "Request message for Bigtable.MutateRow.", "id": "GoogleBigtableV2..MutateRowRequest" }, "GoogleBigtableV2..ResponseParams": { "properties": { "afeId": { "type": "string", "description": "The AFE ID for the AFE that is served this request.", "format": "int64" }, "zoneId": { "description": "The cloud bigtable zone associated with the cluster.", "type": "string" }, "clusterId": { "type": "string", "description": "Identifier for a cluster that represents set of bigtable resources." } }, "type": "object", "id": "GoogleBigtableV2..ResponseParams", "description": "Response metadata proto" }, "GoogleBigtableV2.Type.Proto": { "properties": { "schemaBundleId": { "description": "The ID of the schema bundle that this proto is defined in.", "type": "string" }, "messageName": { "type": "string", "description": "The fully qualified name of the protobuf message, including package. In the format of \"foo.bar.Message\"." } }, "description": "A protobuf message type. Values of type `Proto` are stored in `Value.bytes_value`.", "id": "GoogleBigtableV2.Type.Proto", "type": "object" }, "GoogleBigtableV2..ProtoSchema": { "properties": { "columns": { "type": "array", "description": "The columns in the result set.", "items": { "$ref": "GoogleBigtableV2..ColumnMetadata" } } }, "type": "object", "id": "GoogleBigtableV2..ProtoSchema", "description": "ResultSet schema in proto format" }, "GoogleBigtableV2.TypeInt32Encoding.OrderedCodeBytes": { "type": "object", "description": "Encodes the value in a variable length binary format of up to 5 bytes. Values that are closer to zero use fewer bytes. Sorted mode: all values are supported. Distinct mode: all values are supported.", "id": "GoogleBigtableV2.TypeInt32Encoding.OrderedCodeBytes", "properties": {} }, "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsResponse": { "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. Response message for Bigtable.GenerateInitialChangeStreamPartitions.", "type": "object", "properties": { "partition": { "description": "A partition of the change stream.", "$ref": "GoogleBigtableV2..StreamPartition" } }, "id": "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsResponse" }, "GoogleBigtableV2..RequestLatencyStats": { "type": "object", "properties": { "frontendServerLatency": { "type": "string", "format": "google-duration", "description": "The latency measured by the frontend server handling this request, from when the request was received, to when this value is sent back in the response. For more context on the component that is measuring this latency, see: https://cloud.google.com/bigtable/docs/overview Note: This value may be slightly shorter than the value reported into aggregate latency metrics in Monitoring for this request (https://cloud.google.com/bigtable/docs/monitoring-instance) as this value needs to be sent in the response before the latency measurement including that transmission is finalized. Note: This value includes the end-to-end latency of contacting nodes in the targeted cluster, e.g. measuring from when the first byte arrives at the frontend server, to when this value is sent back as the last value in the response, including any latency incurred by contacting nodes, waiting for results from nodes, and finally sending results from nodes back to the caller." } }, "description": "RequestLatencyStats provides a measurement of the latency of the request as it interacts with different systems over its lifetime, e.g. how long the request took to execute within a frontend server.", "id": "GoogleBigtableV2..RequestLatencyStats" }, "GoogleBigtableV2..PrepareQueryRequest": { "id": "GoogleBigtableV2..PrepareQueryRequest", "description": "Request message for Bigtable.PrepareQuery", "type": "object", "properties": { "paramTypes": { "description": "Required. `param_types` is a map of parameter identifier strings to their `Type`s. In query string, a parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`) in the query string. For example, if param_types[\"firstName\"] = Bytes then @firstName will be a query parameter of type Bytes. The specific `Value` to be used for the query execution must be sent in `ExecuteQueryRequest` in the `params` map.", "additionalProperties": { "$ref": "GoogleBigtableV2..Type" }, "type": "object" }, "query": { "type": "string", "description": "Required. The query string." }, "protoFormat": { "description": "Protocol buffer format as described by ProtoSchema and ProtoRows messages.", "$ref": "GoogleBigtableV2..ProtoFormat" }, "appProfileId": { "type": "string", "description": "Optional. This value specifies routing for preparing the query. Note that this `app_profile_id` is only used for preparing the query. The actual query execution will use the app profile specified in the `ExecuteQueryRequest`. If not specified, the `default` application profile will be used." } } }, "GoogleBigtableV2..PrepareQueryResponse": { "properties": { "validUntil": { "type": "string", "format": "google-datetime", "description": "The time at which the prepared query token becomes invalid. A token may become invalid early due to changes in the data being read, but it provides a guideline to refresh query plans asynchronously." }, "metadata": { "description": "Structure of rows in the response stream of `ExecuteQueryResponse` for the returned `prepared_query`.", "$ref": "GoogleBigtableV2..ResultSetMetadata" }, "preparedQuery": { "type": "string", "description": "A serialized prepared query. Clients should treat this as an opaque blob of bytes to send in `ExecuteQueryRequest`.", "format": "byte" } }, "id": "GoogleBigtableV2..PrepareQueryResponse", "type": "object", "description": "Response message for Bigtable.PrepareQueryResponse" }, "GoogleBigtableV2.Type.Int64": { "type": "object", "description": "Int64 Values of type `Int64` are stored in `Value.int_value`.", "id": "GoogleBigtableV2.Type.Int64", "properties": { "encoding": { "description": "The encoding to use when converting to or from lower level types.", "$ref": "GoogleBigtableV2.TypeInt64.Encoding" } } }, "GoogleBigtableV2..MutateRowResponse": { "id": "GoogleBigtableV2..MutateRowResponse", "type": "object", "properties": {}, "description": "Response message for Bigtable.MutateRow." }, "GoogleBigtableV2..SessionMutateRowsRequest": { "type": "object", "properties": { "entries": { "type": "array", "items": { "$ref": "GoogleBigtableV2.SessionMutateRowsRequest.Entry" }, "description": "The row keys and corresponding mutations to be applied in bulk." } }, "id": "GoogleBigtableV2..SessionMutateRowsRequest", "description": "Internal usage only." }, "GoogleBigtableV2..SessionMutateRowRequest": { "type": "object", "description": "Internal usage only.", "id": "GoogleBigtableV2..SessionMutateRowRequest", "properties": { "mutations": { "items": { "$ref": "GoogleBigtableV2..Mutation" }, "type": "array" }, "key": { "format": "byte", "type": "string" } } }, "GoogleBigtableV2.ReadChangeStreamResponse.Heartbeat": { "description": "A periodic message with information that can be used to checkpoint the state of a stream.", "id": "GoogleBigtableV2.ReadChangeStreamResponse.Heartbeat", "type": "object", "properties": { "continuationToken": { "description": "A token that can be provided to a subsequent `ReadChangeStream` call to pick up reading at the current stream position.", "$ref": "GoogleBigtableV2..StreamContinuationToken" }, "estimatedLowWatermark": { "format": "google-datetime", "type": "string", "description": "An estimate of the commit timestamp that is usually lower than or equal to any timestamp for a record that will be delivered in the future on the stream. It is possible that, under particular circumstances that a future record has a timestamp that is lower than a previously seen timestamp. For an example usage see https://beam.apache.org/documentation/basics/#watermarks" } } }, "GoogleBigtableV2.TypeInt32Encoding.BigEndianBytes": { "type": "object", "description": "Encodes the value as a 4-byte big-endian two's complement value. Sorted mode: non-negative values are supported. Distinct mode: all values are supported. Compatible with: - BigQuery `BINARY` encoding - HBase `Bytes.toBytes` - Java `ByteBuffer.putInt()` with `ByteOrder.BIG_ENDIAN`", "properties": {}, "id": "GoogleBigtableV2.TypeInt32Encoding.BigEndianBytes" }, "GoogleBigtableV2.Type.Enum": { "description": "A protobuf enum type. Values of type `Enum` are stored in `Value.int_value`.", "type": "object", "id": "GoogleBigtableV2.Type.Enum", "properties": { "schemaBundleId": { "description": "The ID of the schema bundle that this enum is defined in.", "type": "string" }, "enumName": { "description": "The fully qualified name of the protobuf enum message, including package. In the format of \"foo.bar.EnumMessage\".", "type": "string" } } }, "GoogleBigtableV2.ReadChangeStreamResponse.MutationChunk": { "id": "GoogleBigtableV2.ReadChangeStreamResponse.MutationChunk", "description": "A partial or complete mutation.", "properties": { "mutation": { "$ref": "GoogleBigtableV2..Mutation", "description": "If this is a continuation of a chunked message (`chunked_value_offset` \u003e 0), ignore all fields except the `SetCell`'s value and merge it with the previous message by concatenating the value fields." }, "chunkInfo": { "description": "If set, then the mutation is a `SetCell` with a chunked value across multiple messages.", "$ref": "GoogleBigtableV2.ReadChangeStreamResponseMutationChunk.ChunkInfo" } }, "type": "object" }, "GoogleBigtableV2..ValueBitmask": { "properties": { "mask": { "format": "byte", "type": "string", "description": "Required. Mask applied to the value. Evaluated as: `(value & mask) == mask` The mask length must exactly match the value length, otherwise the cell is not considered a match." } }, "id": "GoogleBigtableV2..ValueBitmask", "type": "object", "description": "Restricts the output to cells whose values match the given bitmask." }, "GoogleBigtableV2..Type": { "type": "object", "properties": { "structType": { "description": "Struct", "$ref": "GoogleBigtableV2.Type.Struct" }, "float64Type": { "$ref": "GoogleBigtableV2.Type.Float64", "description": "Float64" }, "enumType": { "$ref": "GoogleBigtableV2.Type.Enum", "description": "Enum" }, "int64Type": { "description": "Int64", "$ref": "GoogleBigtableV2.Type.Int64" }, "aggregateType": { "description": "Aggregate", "$ref": "GoogleBigtableV2.Type.Aggregate" }, "geographyType": { "$ref": "GoogleBigtableV2.Type.Geography", "description": "Geography" }, "bytesType": { "description": "Bytes", "$ref": "GoogleBigtableV2.Type.Bytes" }, "protoType": { "$ref": "GoogleBigtableV2.Type.Proto", "description": "Proto" }, "dateType": { "description": "Date", "$ref": "GoogleBigtableV2.Type.Date" }, "timestampType": { "$ref": "GoogleBigtableV2.Type.Timestamp", "description": "Timestamp" }, "stringType": { "description": "String", "$ref": "GoogleBigtableV2.Type.String" }, "mapType": { "description": "Map", "$ref": "GoogleBigtableV2.Type.Map" }, "boolType": { "$ref": "GoogleBigtableV2.Type.Bool", "description": "Bool" }, "float32Type": { "$ref": "GoogleBigtableV2.Type.Float32", "description": "Float32" }, "arrayType": { "description": "Array", "$ref": "GoogleBigtableV2.Type.Array" }, "int32Type": { "$ref": "GoogleBigtableV2.Type.Int32", "description": "Int32" } }, "id": "GoogleBigtableV2..Type", "description": "`Type` represents the type of data that is written to, read from, or stored in Bigtable. It is heavily based on the GoogleSQL standard to help maintain familiarity and consistency across products and features. For compatibility with Bigtable's existing untyped APIs, each `Type` includes an `Encoding` which describes how to convert to or from the underlying data. Each encoding can operate in one of two modes: - Sorted: In this mode, Bigtable guarantees that `Encode(X) \u003c= Encode(Y)` if and only if `X \u003c= Y`. This is useful anywhere sort order is important, for example when encoding keys. - Distinct: In this mode, Bigtable guarantees that if `X != Y` then `Encode(X) != Encode(Y)`. However, the converse is not guaranteed. For example, both `{'foo': '1', 'bar': '2'}` and `{'bar': '2', 'foo': '1'}` are valid encodings of the same JSON value. The API clearly documents which mode is used wherever an encoding can be configured. Each encoding also documents which values are supported in which modes. For example, when encoding INT64 as a numeric STRING, negative numbers cannot be encoded in sorted mode. This is because `INT64(1) \u003e INT64(-1)`, but `STRING(\"-00001\") \u003e STRING(\"00001\")`." }, "GoogleBigtableV2..CheckAndMutateRowRequest": { "description": "Request message for Bigtable.CheckAndMutateRow.", "type": "object", "id": "GoogleBigtableV2..CheckAndMutateRowRequest", "properties": { "predicateFilter": { "$ref": "GoogleBigtableV2..RowFilter", "description": "The filter to be applied to the contents of the specified row. Depending on whether or not any results are yielded, either `true_mutations` or `false_mutations` will be executed. If unset, checks that the row contains any values at all." }, "rowKey": { "type": "string", "format": "byte", "description": "Required. The key of the row to which the conditional mutation should be applied." }, "authorizedViewName": { "description": "Optional. The unique name of the AuthorizedView to which the conditional mutation should be applied. Values are of the form `projects//instances//tables//authorizedViews/`.", "type": "string" }, "tableName": { "type": "string", "description": "Optional. The unique name of the table to which the conditional mutation should be applied. Values are of the form `projects//instances//tables/`." }, "falseMutations": { "type": "array", "description": "Changes to be atomically applied to the specified row if `predicate_filter` does not yield any cells when applied to `row_key`. Entries are applied in order, meaning that earlier mutations can be masked by later ones. Must contain at least one entry if `true_mutations` is empty, and at most 100000.", "items": { "$ref": "GoogleBigtableV2..Mutation" } }, "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "type": "string" }, "trueMutations": { "items": { "$ref": "GoogleBigtableV2..Mutation" }, "description": "Changes to be atomically applied to the specified row if `predicate_filter` yields at least one cell when applied to `row_key`. Entries are applied in order, meaning that earlier mutations can be masked by later ones. Must contain at least one entry if `false_mutations` is empty, and at most 100000.", "type": "array" } } }, "GoogleBigtableV2..Row": { "description": "Specifies the complete (requested) contents of a single row of a table.", "properties": { "families": { "type": "array", "description": "May be empty, but only if the entire row is empty. The mutual ordering of column families is not specified.", "items": { "$ref": "GoogleBigtableV2..Family" } }, "key": { "type": "string", "description": "The unique key which identifies this row within its table. This is the same key that's used to identify the row in, for example, a MutateRowRequest. May contain any non-empty byte string up to 4KiB in length.", "format": "byte" } }, "type": "object", "id": "GoogleBigtableV2..Row" }, "GoogleBigtableV2.TypeStringEncoding.Utf8Raw": { "type": "object", "description": "Deprecated: prefer the equivalent `Utf8Bytes`.", "properties": {}, "deprecated": true, "id": "GoogleBigtableV2.TypeStringEncoding.Utf8Raw" }, "GoogleBigtableV2..ProtoRows": { "description": "Rows represented in proto format. This should be constructed by concatenating the `batch_data` from each of the relevant `ProtoRowsBatch` messages and parsing the result as a `ProtoRows` message.", "properties": { "values": { "description": "A proto rows message consists of a list of values. Every N complete values defines a row, where N is equal to the number of entries in the `metadata.proto_schema.columns` value received in the first response.", "items": { "$ref": "GoogleBigtableV2..Value" }, "type": "array" } }, "id": "GoogleBigtableV2..ProtoRows", "type": "object" }, "GoogleBigtableV2.Mutation.MergeToCell": { "description": "A Mutation which merges accumulated state into a cell in an `Aggregate` family.", "type": "object", "id": "GoogleBigtableV2.Mutation.MergeToCell", "properties": { "timestamp": { "description": "The timestamp of the cell to which new data should be added. This must be a `raw_timestamp_micros` that matches the table's `granularity`.", "$ref": "GoogleBigtableV2..Value" }, "familyName": { "type": "string", "description": "The name of the `Aggregate` family into which new data should be added. This must be a family with a `value_type` of `Aggregate`. Format: `[-_.a-zA-Z0-9]+`" }, "columnQualifier": { "description": "The qualifier of the column into which new data should be added. This must be a `raw_value`.", "$ref": "GoogleBigtableV2..Value" }, "input": { "description": "The input value to be merged into the specified cell. This must be compatible with the family's `value_type.state_type`. Merging `NULL` is allowed, but has no effect.", "$ref": "GoogleBigtableV2..Value" } } }, "GoogleBigtableV2..OpenMaterializedViewRequest": { "description": "Open sessions for a MaterializedView. Internal usage only.", "properties": { "permission": { "description": "Permission for the session.", "enum": [ "PERMISSION_UNSET", "PERMISSION_READ" ], "enumDescriptions": [ "", "" ], "type": "string" }, "appProfileId": { "description": "The app profile id to use for the materialized view sessions.", "type": "string" }, "materializedViewName": { "description": "The Materialized view name to read and write from. Values are of the form `projects//instances//materializedViews/`.", "type": "string" } }, "type": "object", "id": "GoogleBigtableV2..OpenMaterializedViewRequest" }, "GoogleBigtableV2.Type.Bytes": { "id": "GoogleBigtableV2.Type.Bytes", "properties": { "encoding": { "$ref": "GoogleBigtableV2.TypeBytes.Encoding", "description": "The encoding to use when converting to or from lower level types." } }, "type": "object", "description": "Bytes Values of type `Bytes` are stored in `Value.bytes_value`." }, "GoogleBigtableV2.Type.Float32": { "id": "GoogleBigtableV2.Type.Float32", "type": "object", "description": "Float32 Values of type `Float32` are stored in `Value.float_value`.", "properties": {} }, "GoogleBigtableV2..OpenMaterializedViewResponse": { "id": "GoogleBigtableV2..OpenMaterializedViewResponse", "description": "Internal usage only.", "type": "object", "properties": {} }, "GoogleBigtableV2.TypeAggregate.Sum": { "id": "GoogleBigtableV2.TypeAggregate.Sum", "properties": {}, "description": "Computes the sum of the input values. Allowed input: `Int64` State: same as input", "type": "object" }, "GoogleBigtableV2.TypeAggregate.HyperLogLogPlusPlusUniqueCount": { "properties": {}, "description": "Computes an approximate unique count over the input values. When using raw data as input, be careful to use a consistent encoding. Otherwise the same value encoded differently could count more than once, or two distinct values could count as identical. Input: Any, or omit for Raw State: TBD Special state conversions: `Int64` (the unique count estimate)", "id": "GoogleBigtableV2.TypeAggregate.HyperLogLogPlusPlusUniqueCount", "type": "object" }, "GoogleBigtableV2..ReadRowsResponse": { "properties": { "requestStats": { "$ref": "GoogleBigtableV2..RequestStats", "description": "If requested, return enhanced query performance statistics. The field request_stats is empty in a streamed response unless the ReadRowsResponse message contains request_stats in the last message of the stream. Always returned when requested, even when the read request returns an empty response." }, "chunks": { "description": "A collection of a row's contents as part of the read request.", "items": { "$ref": "GoogleBigtableV2.ReadRowsResponse.CellChunk" }, "type": "array" }, "lastScannedRowKey": { "description": "Optionally the server might return the row key of the last row it has scanned. The client can use this to construct a more efficient retry request if needed: any row keys or portions of ranges less than this row key can be dropped from the request. This is primarily useful for cases where the server has read a lot of data that was filtered out since the last committed row key, allowing the client to skip that work on a retry.", "type": "string", "format": "byte" } }, "type": "object", "description": "Response message for Bigtable.ReadRows.", "id": "GoogleBigtableV2..ReadRowsResponse" }, "GoogleBigtableV2..CheckAndMutateRowResponse": { "properties": { "predicateMatched": { "description": "Whether or not the request's `predicate_filter` yielded any results for the specified row.", "type": "boolean" } }, "type": "object", "description": "Response message for Bigtable.CheckAndMutateRow.", "id": "GoogleBigtableV2..CheckAndMutateRowResponse" }, "GoogleBigtableV2..ReadModifyWriteRowRequest": { "type": "object", "properties": { "rowKey": { "description": "Required. The key of the row to which the read/modify/write rules should be applied.", "format": "byte", "type": "string" }, "rules": { "items": { "$ref": "GoogleBigtableV2..ReadModifyWriteRule" }, "description": "Required. Rules specifying how the specified row's contents are to be transformed into writes. Entries are applied in order, meaning that earlier rules will affect the results of later ones. At least one entry must be specified, and there can be at most 100000 rules.", "type": "array" }, "authorizedViewName": { "type": "string", "description": "Optional. The unique name of the AuthorizedView to which the read/modify/write rules should be applied. Values are of the form `projects//instances//tables//authorizedViews/`." }, "appProfileId": { "type": "string", "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used." }, "tableName": { "description": "Optional. The unique name of the table to which the read/modify/write rules should be applied. Values are of the form `projects//instances//tables/`.", "type": "string" } }, "id": "GoogleBigtableV2..ReadModifyWriteRowRequest", "description": "Request message for Bigtable.ReadModifyWriteRow." }, "GoogleBigtableV2.ReadChangeStreamResponseMutationChunk.ChunkInfo": { "type": "object", "properties": { "lastChunk": { "description": "When true, this is the last chunk of a chunked `SetCell`.", "type": "boolean" }, "chunkedValueOffset": { "description": "The byte offset of this chunk into the total value size of the mutation.", "format": "int32", "type": "integer" }, "chunkedValueSize": { "type": "integer", "description": "The total value size of all the chunks that make up the `SetCell`.", "format": "int32" } }, "id": "GoogleBigtableV2.ReadChangeStreamResponseMutationChunk.ChunkInfo", "description": "Information about the chunking of this mutation. Only `SetCell` mutations can be chunked, and all chunks for a `SetCell` will be delivered contiguously with no other mutation types interleaved." }, "GoogleBigtableV2..SessionReadRowsRequest": { "description": "Internal usage only.", "type": "object", "id": "GoogleBigtableV2..SessionReadRowsRequest", "properties": { "rowsLimit": { "format": "int64", "type": "string" }, "filter": { "$ref": "GoogleBigtableV2..RowFilter" }, "reversed": { "type": "boolean" }, "rows": { "$ref": "GoogleBigtableV2..RowSet" } } }, "GoogleBigtableV2..SessionMutateRowResponse": { "id": "GoogleBigtableV2..SessionMutateRowResponse", "description": "Internal usage only.", "type": "object", "properties": {} }, "GoogleBigtableV2..ReadModifyWriteRowResponse": { "id": "GoogleBigtableV2..ReadModifyWriteRowResponse", "description": "Response message for Bigtable.ReadModifyWriteRow.", "type": "object", "properties": { "row": { "$ref": "GoogleBigtableV2..Row", "description": "A Row containing the new contents of all cells modified by the request." } } }, "GoogleBigtableV2.SessionMutateRowsResponse.Entry": { "type": "object", "properties": { "status": { "$ref": "GoogleRpc..Status", "description": "The result of the request Entry identified by `index`." }, "index": { "type": "string", "format": "int64", "description": "The index into the original request's `entries` list of the Entry for which a result is being reported." } }, "description": "The result of applying a passed mutation in the original request.", "id": "GoogleBigtableV2.SessionMutateRowsResponse.Entry" }, "GoogleBigtableV2.TypeBytesEncoding.Raw": { "type": "object", "properties": { "escapeNulls": { "description": "If set, allows NULL values to be encoded as the empty string \"\". The actual empty string, or any value which only contains the null byte `0x00`, has one more null byte appended.", "type": "boolean" } }, "description": "Leaves the value as-is. Sorted mode: all values are supported. Distinct mode: all values are supported.", "id": "GoogleBigtableV2.TypeBytesEncoding.Raw" }, "GoogleBigtableV2.TypeStruct.Field": { "type": "object", "id": "GoogleBigtableV2.TypeStruct.Field", "description": "A struct field and its type.", "properties": { "type": { "description": "The type of values in this field.", "$ref": "GoogleBigtableV2..Type" }, "fieldName": { "description": "The field name (optional). Fields without a `field_name` are considered anonymous and cannot be referenced by name.", "type": "string" } } }, "GoogleBigtableV2.Type.Struct": { "properties": { "fields": { "type": "array", "items": { "$ref": "GoogleBigtableV2.TypeStruct.Field" }, "description": "The names and types of the fields in this struct." }, "encoding": { "description": "The encoding to use when converting to or from lower level types.", "$ref": "GoogleBigtableV2.TypeStruct.Encoding" } }, "id": "GoogleBigtableV2.Type.Struct", "description": "A structured data value, consisting of fields which map to dynamically typed values. Values of type `Struct` are stored in `Value.array_value` where entries are in the same order and number as `field_types`.", "type": "object" }, "GoogleBigtableV2.TypeStringEncoding.Utf8Bytes": { "id": "GoogleBigtableV2.TypeStringEncoding.Utf8Bytes", "description": "UTF-8 encoding. Sorted mode: - All values are supported. - Code point order is preserved. Distinct mode: all values are supported. Compatible with: - BigQuery `TEXT` encoding - HBase `Bytes.toBytes` - Java `String#getBytes(StandardCharsets.UTF_8)`", "type": "object", "properties": { "nullEscapeChar": { "description": "Single-character escape sequence used to support NULL values. If set, allows NULL values to be encoded as the empty string \"\". The actual empty string, or any value where every character equals `null_escape_char`, has one more `null_escape_char` appended. If `null_escape_char` is set and does not equal the ASCII null character `0x00`, then the encoding will not support sorted mode. .", "type": "string" } } }, "GoogleBigtableV2.MutateRowsResponse.Entry": { "type": "object", "id": "GoogleBigtableV2.MutateRowsResponse.Entry", "description": "The result of applying a passed mutation in the original request.", "properties": { "index": { "description": "The index into the original request's `entries` list of the Entry for which a result is being reported.", "type": "string", "format": "int64" }, "status": { "$ref": "GoogleRpc..Status", "description": "The result of the request Entry identified by `index`. Depending on how requests are batched during execution, it is possible for one Entry to fail due to an error with another Entry. In the event that this occurs, the same error will be reported for both entries." } } }, "GoogleBigtableV2..FeatureFlags": { "description": "Feature flags supported or enabled by a client. This is intended to be sent as part of request metadata to assure the server that certain behaviors are safe to enable. This proto is meant to be serialized and websafe-base64 encoded under the `bigtable-features` metadata key. The value will remain constant for the lifetime of a client and due to HTTP2's HPACK compression, the request overhead will be tiny. This is an internal implementation detail and should not be used by end users directly.", "id": "GoogleBigtableV2..FeatureFlags", "type": "object", "properties": { "retryInfo": { "type": "boolean", "description": "Notify the server that the client supports using retry info back off durations to retry requests with." }, "microsecondTimestamp": { "description": "Optional. Indicates whether the client supports microsecond precision timestamps.", "type": "boolean" }, "peerLoadInfo": { "type": "boolean", "description": "Optional. Indicates whether the client can ingest peer load info from the server." }, "routingCookie": { "type": "boolean", "description": "Notify the server that the client supports using encoded routing cookie strings to retry requests with." }, "reverseScans": { "description": "Notify the server that the client supports reverse scans. The server will reject ReadRowsRequests with the reverse bit set when this is absent.", "type": "boolean" }, "clientSideMetricsEnabled": { "type": "boolean", "description": "Notify the server that the client has client side metrics enabled." }, "sessionsRequired": { "type": "boolean", "description": "Internal flag to force sessions for internal projects." }, "peerInfo": { "description": "If the client can support using BigtablePeerInfo.", "type": "boolean" }, "directAccessRequested": { "description": "Notify the server that the client explicitly opted in for Direct Access.", "type": "boolean" }, "trafficDirectorEnabled": { "type": "boolean", "description": "Notify the server that the client using Traffic Director endpoint." }, "mutateRowsRateLimit2": { "type": "boolean", "description": "Notify the server that the client enables batch write flow control by requesting RateLimitInfo from MutateRowsResponse. With partial retries enabled." }, "sessionsCompatible": { "type": "boolean", "description": "Indicates whether the client supports the Bigtable Sessions API." }, "lastScannedRowResponses": { "type": "boolean", "description": "Notify the server that the client supports the last_scanned_row field in ReadRowsResponse for long-running scans." }, "mutateRowsRateLimit": { "description": "Notify the server that the client enables batch write flow control by requesting RateLimitInfo from MutateRowsResponse. Due to technical reasons, this disables partial retries.", "type": "boolean" } } }, "GoogleBigtableV2..RowFilter": { "description": "Takes a row as input and produces an alternate view of the row based on specified rules. For example, a RowFilter might trim down a row to include just the cells from columns matching a given regular expression, or might return all the cells of a row but not their values. More complicated filters can be composed out of these components to express requests such as, \"within every column of a particular family, give just the two most recent cells which are older than timestamp X.\" There are two broad categories of RowFilters (true filters and transformers), as well as two ways to compose simple filters into more complex ones (chains and interleaves). They work as follows: * True filters alter the input row by excluding some of its cells wholesale from the output row. An example of a true filter is the `value_regex_filter`, which excludes cells whose values don't match the specified pattern. All regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax) in raw byte mode (RE2::Latin1), and are evaluated as full matches. An important point to keep in mind is that `RE2(.)` is equivalent by default to `RE2([^\\n])`, meaning that it does not match newlines. When attempting to match an arbitrary byte, you should therefore use the escape sequence `\\C`, which may need to be further escaped as `\\\\C` in your client language. * Transformers alter the input row by changing the values of some of its cells in the output, without excluding them completely. Currently, the only supported transformer is the `strip_value_transformer`, which replaces every cell's value with the empty string. * Chains and interleaves are described in more detail in the RowFilter.Chain and RowFilter.Interleave documentation. The total serialized size of a RowFilter message must not exceed 20480 bytes, and RowFilters may not be nested within each other (in Chains or Interleaves) to a depth of more than 20.", "properties": { "columnQualifierRegexFilter": { "description": "Matches only cells from columns whose qualifiers satisfy the given RE2 regex. Note that, since column qualifiers can contain arbitrary bytes, the `\\C` escape sequence must be used if a true wildcard is desired. The `.` character will not match the new line character `\\n`, which may be present in a binary qualifier.", "format": "byte", "type": "string" }, "cellsPerColumnLimitFilter": { "type": "integer", "description": "Matches only the most recent N cells within each column. For example, if N=2, this filter would match column `foo:bar` at timestamps 10 and 9, skip all earlier cells in `foo:bar`, and then begin matching again in column `foo:bar2`. If duplicate cells are present, as is possible when using an Interleave, each copy of the cell is counted separately.", "format": "int32" }, "passAllFilter": { "type": "boolean", "description": "Matches all cells, regardless of input. Functionally equivalent to leaving `filter` unset, but included for completeness." }, "valueBitmaskFilter": { "description": "Matches only cells with values that satisfy the condition `(value & mask) == mask`. The mask length must exactly match the value length, otherwise the cell is not considered a match.", "$ref": "GoogleBigtableV2..ValueBitmask" }, "rowSampleFilter": { "description": "Matches all cells from a row with probability p, and matches no cells from the row with probability 1-p.", "format": "double", "type": "number" }, "sink": { "type": "boolean", "description": "ADVANCED USE ONLY. Hook for introspection into the RowFilter. Outputs all cells directly to the output of the read rather than to any parent filter. Consider the following example: Chain( FamilyRegex(\"A\"), Interleave( All(), Chain(Label(\"foo\"), Sink()) ), QualifierRegex(\"B\") ) A,A,1,w A,B,2,x B,B,4,z | FamilyRegex(\"A\") | A,A,1,w A,B,2,x | +------------+-------------+ | | All() Label(foo) | | A,A,1,w A,A,1,w,labels:[foo] A,B,2,x A,B,2,x,labels:[foo] | | | Sink() --------------+ | | | +------------+ x------+ A,A,1,w,labels:[foo] | A,B,2,x,labels:[foo] A,A,1,w | A,B,2,x | | | QualifierRegex(\"B\") | | | A,B,2,x | | | +--------------------------------+ | A,A,1,w,labels:[foo] A,B,2,x,labels:[foo] // could be switched A,B,2,x // could be switched Despite being excluded by the qualifier filter, a copy of every cell that reaches the sink is present in the final result. As with an Interleave, duplicate cells are possible, and appear in an unspecified mutual order. In this case we have a duplicate with column \"A:B\" and timestamp 2, because one copy passed through the all filter while the other was passed through the label and sink. Note that one copy has label \"foo\", while the other does not. Cannot be used within the `predicate_filter`, `true_filter`, or `false_filter` of a Condition." }, "familyNameRegexFilter": { "description": "Matches only cells from columns whose families satisfy the given RE2 regex. For technical reasons, the regex must not contain the `:` character, even if it is not being used as a literal. Note that, since column families cannot contain the new line character `\\n`, it is sufficient to use `.` as a full wildcard when matching column family names.", "type": "string" }, "applyLabelTransformer": { "description": "Applies the given label to all cells in the output row. This allows the client to determine which results were produced from which part of the filter. Values must be at most 15 characters in length, and match the RE2 pattern `[a-z0-9\\\\-]+` Due to a technical limitation, it is not currently possible to apply multiple labels to a cell. As a result, a Chain may have no more than one sub-filter which contains a `apply_label_transformer`. It is okay for an Interleave to contain multiple `apply_label_transformers`, as they will be applied to separate copies of the input. This may be relaxed in the future.", "type": "string" }, "interleave": { "description": "Applies several RowFilters to the data in parallel and combines the results.", "$ref": "GoogleBigtableV2.RowFilter.Interleave" }, "blockAllFilter": { "description": "Does not match any cells, regardless of input. Useful for temporarily disabling just part of a filter.", "type": "boolean" }, "condition": { "description": "Applies one of two possible RowFilters to the data based on the output of a predicate RowFilter.", "$ref": "GoogleBigtableV2.RowFilter.Condition" }, "valueRegexFilter": { "type": "string", "format": "byte", "description": "Matches only cells with values that satisfy the given regular expression. Note that, since cell values can contain arbitrary bytes, the `\\C` escape sequence must be used if a true wildcard is desired. The `.` character will not match the new line character `\\n`, which may be present in a binary value." }, "rowKeyRegexFilter": { "type": "string", "format": "byte", "description": "Matches only cells from rows whose keys satisfy the given RE2 regex. In other words, passes through the entire row when the key matches, and otherwise produces an empty row. Note that, since row keys can contain arbitrary bytes, the `\\C` escape sequence must be used if a true wildcard is desired. The `.` character will not match the new line character `\\n`, which may be present in a binary key." }, "cellsPerRowOffsetFilter": { "description": "Skips the first N cells of each row, matching all subsequent cells. If duplicate cells are present, as is possible when using an Interleave, each copy of the cell is counted separately.", "format": "int32", "type": "integer" }, "cellsPerRowLimitFilter": { "type": "integer", "format": "int32", "description": "Matches only the first N cells of each row. If duplicate cells are present, as is possible when using an Interleave, each copy of the cell is counted separately." }, "columnRangeFilter": { "$ref": "GoogleBigtableV2..ColumnRange", "description": "Matches only cells from columns within the given range." }, "valueRangeFilter": { "description": "Matches only cells with values that fall within the given range.", "$ref": "GoogleBigtableV2..ValueRange" }, "timestampRangeFilter": { "description": "Matches only cells with timestamps within the given range.", "$ref": "GoogleBigtableV2..TimestampRange" }, "stripValueTransformer": { "description": "Replaces each cell's value with the empty string.", "type": "boolean" }, "chain": { "description": "Applies several RowFilters to the data in sequence, progressively narrowing the results.", "$ref": "GoogleBigtableV2.RowFilter.Chain" } }, "id": "GoogleBigtableV2..RowFilter", "type": "object" }, "GoogleBigtableV2..TableRequest": { "type": "object", "description": "Internal usage only.", "properties": { "checkAndMutateRow": { "$ref": "GoogleBigtableV2..SessionCheckAndMutateRowRequest" }, "readModifyWriteRow": { "$ref": "GoogleBigtableV2..SessionReadModifyWriteRowRequest" }, "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsRequest" }, "mutateRows": { "$ref": "GoogleBigtableV2..SessionMutateRowsRequest" }, "mutateRow": { "$ref": "GoogleBigtableV2..SessionMutateRowRequest" }, "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowRequest" } }, "id": "GoogleBigtableV2..TableRequest" }, "GoogleBigtableV2.TypeStructEncoding.Singleton": { "properties": {}, "id": "GoogleBigtableV2.TypeStructEncoding.Singleton", "description": "Uses the encoding of `fields[0].type` as-is. Only valid if `fields.size == 1`. This encoding does not support `DESC` field ordering.", "type": "object" }, "GoogleBigtableV2..ProtoFormat": { "description": "Protocol buffers format descriptor, as described by Messages ProtoSchema and ProtoRows", "properties": {}, "id": "GoogleBigtableV2..ProtoFormat", "type": "object" }, "GoogleBigtableV2.Mutation.DeleteFromFamily": { "id": "GoogleBigtableV2.Mutation.DeleteFromFamily", "properties": { "familyName": { "type": "string", "description": "The name of the family from which cells should be deleted. Must match `[-_.a-zA-Z0-9]+`" } }, "type": "object", "description": "A Mutation which deletes all cells from the specified column family." }, "GoogleBigtableV2.Type.Timestamp": { "description": "Timestamp Values of type `Timestamp` are stored in `Value.timestamp_value`.", "properties": { "encoding": { "description": "The encoding to use when converting to or from lower level types.", "$ref": "GoogleBigtableV2.TypeTimestamp.Encoding" } }, "id": "GoogleBigtableV2.Type.Timestamp", "type": "object" }, "GoogleBigtableV2.Type.Aggregate": { "description": "A value that combines incremental updates into a summarized value. Data is never directly written or read using type `Aggregate`. Writes provide either the `input_type` or `state_type`, and reads always return the `state_type` .", "type": "object", "properties": { "inputType": { "$ref": "GoogleBigtableV2..Type", "description": "Type of the inputs that are accumulated by this `Aggregate`. Use `AddInput` mutations to accumulate new inputs." }, "stateType": { "description": "Output only. Type that holds the internal accumulator state for the `Aggregate`. This is a function of the `input_type` and `aggregator` chosen.", "readOnly": true, "$ref": "GoogleBigtableV2..Type" }, "max": { "$ref": "GoogleBigtableV2.TypeAggregate.Max", "description": "Max aggregator." }, "min": { "$ref": "GoogleBigtableV2.TypeAggregate.Min", "description": "Min aggregator." }, "sum": { "description": "Sum aggregator.", "$ref": "GoogleBigtableV2.TypeAggregate.Sum" }, "hllppUniqueCount": { "$ref": "GoogleBigtableV2.TypeAggregate.HyperLogLogPlusPlusUniqueCount", "description": "HyperLogLogPlusPlusUniqueCount aggregator." } }, "id": "GoogleBigtableV2.Type.Aggregate" }, "GoogleBigtableV2..SessionReadModifyWriteRowRequest": { "properties": { "rules": { "type": "array", "items": { "$ref": "GoogleBigtableV2..ReadModifyWriteRule" } }, "key": { "format": "byte", "type": "string" } }, "type": "object", "id": "GoogleBigtableV2..SessionReadModifyWriteRowRequest", "description": "Internal usage only." }, "GoogleBigtableV2..Cell": { "id": "GoogleBigtableV2..Cell", "description": "Specifies (some of) the contents of a single row/column/timestamp of a table.", "type": "object", "properties": { "labels": { "type": "array", "items": { "type": "string" }, "description": "Labels applied to the cell by a RowFilter." }, "value": { "format": "byte", "type": "string", "description": "The value stored in the cell. May contain any byte string, including the empty string, up to 100MiB in length." }, "timestampMicros": { "type": "string", "description": "The cell's stored timestamp, which also uniquely identifies it within its column. Values are always expressed in microseconds, but individual tables may set a coarser granularity to further restrict the allowed values. For example, a table which specifies millisecond granularity will only allow values of `timestamp_micros` which are multiples of 1000.", "format": "int64" } } }, "GoogleBigtableV2..TimestampRange": { "type": "object", "description": "Specified a contiguous range of microsecond timestamps.", "id": "GoogleBigtableV2..TimestampRange", "properties": { "endTimestampMicros": { "type": "string", "description": "Exclusive upper bound. If left empty, interpreted as infinity.", "format": "int64" }, "startTimestampMicros": { "format": "int64", "type": "string", "description": "Inclusive lower bound. If left empty, interpreted as 0." } } }, "GoogleBigtableV2.Type.Geography": { "type": "object", "description": "A geography type, representing a point or region on Earth. The value is stored in `Value.bytes_value` as Well-Known Binary (WKB) bytes.", "id": "GoogleBigtableV2.Type.Geography", "properties": {} }, "GoogleBigtableV2..RateLimitInfo": { "description": "Information about how client should adjust the load to Bigtable.", "type": "object", "properties": { "factor": { "type": "number", "description": "If it has been at least one `period` since the last load adjustment, the client should multiply the current load by this value to get the new target load. For example, if the current load is 100 and `factor` is 0.8, the new target load should be 80. After adjusting, the client should ignore `factor` until another `period` has passed. The client can measure its load using any unit that's comparable over time. For example, QPS can be used as long as each request involves a similar amount of work.", "format": "double" }, "period": { "type": "string", "description": "Time that clients should wait before adjusting the target rate again. If clients adjust rate too frequently, the impact of the previous adjustment may not have been taken into account and may over-throttle or under-throttle. If clients adjust rate too slowly, they will not be responsive to load changes on server side, and may over-throttle or under-throttle.", "format": "google-duration" } }, "id": "GoogleBigtableV2..RateLimitInfo" }, "GoogleBigtableV2.Type.Float64": { "id": "GoogleBigtableV2.Type.Float64", "properties": {}, "description": "Float64 Values of type `Float64` are stored in `Value.float_value`.", "type": "object" }, "GoogleBigtableV2.ReadRowsResponse.CellChunk": { "type": "object", "description": "Specifies a piece of a row's contents returned as part of the read response stream.", "properties": { "qualifier": { "description": "The column qualifier for this chunk of data. If this message is not present, this CellChunk is a continuation of the same column as the previous CellChunk. Column qualifiers may be empty so clients must check for the presence of this message, not just for `qualifier.value` being non-empty.", "type": "string", "format": "byte" }, "value": { "type": "string", "description": "The value stored in the cell. Cell values can be split across multiple CellChunks. In that case only the value field will be set in CellChunks after the first: the timestamp and labels will only be present in the first CellChunk, even if the first CellChunk came in a previous ReadRowsResponse.", "format": "byte" }, "commitRow": { "description": "Indicates that the client can safely process all previous chunks for `row_key`, as its data has been fully read.", "type": "boolean" }, "resetRow": { "type": "boolean", "description": "Indicates that the client should drop all previous chunks for `row_key`, as it will be re-read from the beginning." }, "labels": { "type": "array", "items": { "type": "string" }, "description": "Labels applied to the cell by a RowFilter. Labels are only set on the first CellChunk per cell." }, "familyName": { "type": "string", "description": "The column family name for this chunk of data. If this message is not present this CellChunk is a continuation of the same column family as the previous CellChunk. The empty string can occur as a column family name in a response so clients must check explicitly for the presence of this message, not just for `family_name.value` being non-empty." }, "valueSize": { "type": "integer", "description": "If this CellChunk is part of a chunked cell value and this is not the final chunk of that cell, value_size will be set to the total length of the cell value. The client can use this size to pre-allocate memory to hold the full cell value.", "format": "int32" }, "rowKey": { "type": "string", "format": "byte", "description": "The row key for this chunk of data. If the row key is empty, this CellChunk is a continuation of the same row as the previous CellChunk in the response stream, even if that CellChunk was in a previous ReadRowsResponse message." }, "timestampMicros": { "format": "int64", "description": "The cell's stored timestamp, which also uniquely identifies it within its column. Values are always expressed in microseconds, but individual tables may set a coarser granularity to further restrict the allowed values. For example, a table which specifies millisecond granularity will only allow values of `timestamp_micros` which are multiples of 1000. Timestamps are only set in the first CellChunk per cell (for cells split into multiple chunks).", "type": "string" } }, "id": "GoogleBigtableV2.ReadRowsResponse.CellChunk" }, "GoogleBigtableV2..SessionReadModifyWriteRowResponse": { "id": "GoogleBigtableV2..SessionReadModifyWriteRowResponse", "properties": { "row": { "$ref": "GoogleBigtableV2..Row" } }, "description": "Internal usage only.", "type": "object" }, "GoogleRpc..Status": { "id": "GoogleRpc..Status", "description": "The `Status` type defines a logical error model that is suitable for different programming environments, including REST APIs and RPC APIs. It is used by [gRPC](https://github.com/grpc). Each `Status` message contains three pieces of data: error code, error message, and error details. You can find out more about this error model and how to work with it in the [API Design Guide](https://cloud.google.com/apis/design/errors).", "type": "object", "properties": { "message": { "type": "string", "description": "A developer-facing error message, which should be in English. Any user-facing error message should be localized and sent in the google.rpc.Status.details field, or localized by the client." }, "details": { "items": { "additionalProperties": { "type": "any", "description": "Properties of the object. Contains field @type with type URL." }, "type": "object" }, "type": "array", "description": "A list of messages that carry the error details. There is a common set of message types for APIs to use." }, "code": { "type": "integer", "format": "int32", "description": "The status code, which should be an enum value of google.rpc.Code." } } }, "GoogleBigtableV2.TypeString.Encoding": { "id": "GoogleBigtableV2.TypeString.Encoding", "description": "Rules used to convert to or from lower level types.", "properties": { "utf8Bytes": { "description": "Use `Utf8Bytes` encoding.", "$ref": "GoogleBigtableV2.TypeStringEncoding.Utf8Bytes" }, "utf8Raw": { "description": "Deprecated: if set, converts to an empty `utf8_bytes`.", "deprecated": true, "$ref": "GoogleBigtableV2.TypeStringEncoding.Utf8Raw" } }, "type": "object" }, "GoogleBigtableV2..RowSet": { "properties": { "rowKeys": { "type": "array", "description": "Single rows included in the set.", "items": { "format": "byte", "type": "string" } }, "rowRanges": { "description": "Contiguous row ranges included in the set.", "items": { "$ref": "GoogleBigtableV2..RowRange" }, "type": "array" } }, "id": "GoogleBigtableV2..RowSet", "description": "Specifies a non-contiguous set of rows.", "type": "object" }, "GoogleBigtableV2..OpenAuthorizedViewRequest": { "id": "GoogleBigtableV2..OpenAuthorizedViewRequest", "type": "object", "description": "Open sessions for an AuthorizedView. Internal usage only.", "properties": { "appProfileId": { "description": "The app profile id to use for the authorized view sessions.", "type": "string" }, "permission": { "enumDescriptions": [ "", "", "", "" ], "enum": [ "PERMISSION_UNSET", "PERMISSION_READ", "PERMISSION_WRITE", "PERMISSION_READ_WRITE" ], "type": "string", "description": "Permission for the session." }, "authorizedViewName": { "description": "The Authorized view name to read and write from. Values are of the form `projects//instances//tables//authorizedViews/`.", "type": "string" } } }, "GoogleBigtableV2.TypeStruct.Encoding": { "id": "GoogleBigtableV2.TypeStruct.Encoding", "description": "Rules used to convert to or from lower level types.", "properties": { "orderedCodeBytes": { "$ref": "GoogleBigtableV2.TypeStructEncoding.OrderedCodeBytes", "description": "User `OrderedCodeBytes` encoding." }, "delimitedBytes": { "$ref": "GoogleBigtableV2.TypeStructEncoding.DelimitedBytes", "description": "Use `DelimitedBytes` encoding." }, "singleton": { "description": "Use `Singleton` encoding.", "$ref": "GoogleBigtableV2.TypeStructEncoding.Singleton" } }, "type": "object" }, "GoogleBigtableV2..Column": { "description": "Specifies (some of) the contents of a single row/column intersection of a table.", "type": "object", "id": "GoogleBigtableV2..Column", "properties": { "cells": { "type": "array", "description": "Must not be empty. Sorted in order of decreasing \"timestamp_micros\".", "items": { "$ref": "GoogleBigtableV2..Cell" } }, "qualifier": { "type": "string", "format": "byte", "description": "The unique key which identifies this column within its family. This is the same key that's used to identify the column in, for example, a RowFilter which sets its `column_qualifier_regex_filter` field. May contain any byte string, including the empty string, up to 16kiB in length." } } }, "GoogleBigtableV2..OpenTableRequest": { "properties": { "permission": { "type": "string", "enum": [ "PERMISSION_UNSET", "PERMISSION_READ", "PERMISSION_WRITE", "PERMISSION_READ_WRITE" ], "enumDescriptions": [ "", "", "", "" ] }, "appProfileId": { "type": "string" }, "tableName": { "type": "string" } }, "description": "Internal usage only.", "type": "object", "id": "GoogleBigtableV2..OpenTableRequest" }, "GoogleBigtableV2..SessionCheckAndMutateRowResponse": { "description": "Internal usage only.", "type": "object", "id": "GoogleBigtableV2..SessionCheckAndMutateRowResponse", "properties": { "predicateMatched": { "type": "boolean" } } }, "GoogleBigtableV2..SampleRowKeysResponse": { "description": "Response message for Bigtable.SampleRowKeys.", "type": "object", "id": "GoogleBigtableV2..SampleRowKeysResponse", "properties": { "rowKey": { "description": "Sorted streamed sequence of sample row keys in the table, restricted to the row_range if specified in the request. The table might have contents before the first row key in the list and after the last one, but a key containing the empty string indicates \"end of table\" and will be the last response given, if present and within the row-range specified in the request. Note that row keys in this list may not have ever been written to or read from, and users should therefore not make any assumptions about the row key structure that are specific to their use case.", "type": "string", "format": "byte" }, "offsetBytes": { "description": "Approximate total storage space used by all rows in the table which precede `row_key` (and if a row-range is specified in the request, which follow what would have been the previous sample before the row-range start). Buffering the contents of all rows between two subsequent samples would require space roughly equal to the difference in their `offset_bytes` fields.", "type": "string", "format": "int64" } } }, "GoogleBigtableV2..ValueRange": { "description": "Specifies a contiguous range of raw byte values.", "id": "GoogleBigtableV2..ValueRange", "type": "object", "properties": { "endValueOpen": { "description": "Used when giving an exclusive upper bound for the range.", "type": "string", "format": "byte" }, "startValueOpen": { "format": "byte", "type": "string", "description": "Used when giving an exclusive lower bound for the range." }, "endValueClosed": { "format": "byte", "type": "string", "description": "Used when giving an inclusive upper bound for the range." }, "startValueClosed": { "format": "byte", "type": "string", "description": "Used when giving an inclusive lower bound for the range." } } }, "GoogleBigtableV2.Type.Date": { "type": "object", "properties": {}, "description": "Date Values of type `Date` are stored in `Value.date_value`.", "id": "GoogleBigtableV2.Type.Date" }, "GoogleBigtableV2..RequestStats": { "id": "GoogleBigtableV2..RequestStats", "properties": { "fullReadStatsView": { "$ref": "GoogleBigtableV2..FullReadStatsView", "description": "Available with the ReadRowsRequest.RequestStatsView.REQUEST_STATS_FULL view, see package google.bigtable.v2." } }, "description": "RequestStats is the container for additional information pertaining to a single request, helpful for evaluating the performance of the sent request. Currently, the following method is supported: google.bigtable.v2.ReadRows", "type": "object" }, "GoogleBigtableV2.TypeInt64.Encoding": { "id": "GoogleBigtableV2.TypeInt64.Encoding", "type": "object", "properties": { "bigEndianBytes": { "description": "Use `BigEndianBytes` encoding.", "$ref": "GoogleBigtableV2.TypeInt64Encoding.BigEndianBytes" }, "orderedCodeBytes": { "$ref": "GoogleBigtableV2.TypeInt64Encoding.OrderedCodeBytes", "description": "Use `OrderedCodeBytes` encoding." } }, "description": "Rules used to convert to or from lower level types." }, "GoogleBigtableV2.TypeBool.Encoding": { "properties": {}, "type": "object", "id": "GoogleBigtableV2.TypeBool.Encoding", "description": "Defines rules used to convert to or from lower level types." }, "GoogleBigtableV2.Type.Bool": { "properties": { "encoding": { "$ref": "GoogleBigtableV2.TypeBool.Encoding", "description": "Specifies the encoding to use when converting to or from lower level types." } }, "description": "bool Values of type `Bool` are stored in `Value.bool_value`.", "id": "GoogleBigtableV2.Type.Bool", "type": "object" }, "GoogleBigtableV2..PartialResultSet": { "description": "A partial result set from the streaming query API. Cloud Bigtable clients buffer partial results received in this message until a `resume_token` is received. The pseudocode below describes how to buffer and parse a stream of `PartialResultSet` messages. Having: - queue of row results waiting to be returned `queue` - extensible buffer of bytes `buffer` - a place to keep track of the most recent `resume_token` for each PartialResultSet `p` received { if p.reset { ensure `queue` is empty ensure `buffer` is empty } if p.estimated_batch_size != 0 { (optional) ensure `buffer` is sized to at least `p.estimated_batch_size` } if `p.proto_rows_batch` is set { append `p.proto_rows_batch.bytes` to `buffer` } if p.batch_checksum is set and `buffer` is not empty { validate the checksum matches the contents of `buffer` (see comments on `batch_checksum`) parse `buffer` as `ProtoRows` message, clearing `buffer` add parsed rows to end of `queue` } if p.resume_token is set { release results in `queue` save `p.resume_token` in `resume_token` } }", "id": "GoogleBigtableV2..PartialResultSet", "type": "object", "properties": { "resumeToken": { "type": "string", "description": "An opaque token sent by the server to allow query resumption and signal that the buffered values constructed from received `partial_rows` can be yielded to the caller. Clients can provide this token in a subsequent request to resume the result stream from the current point. When `resume_token` is non-empty, the buffered values received from `partial_rows` since the last non-empty `resume_token` can be yielded to the callers, provided that the client keeps the value of `resume_token` and uses it on subsequent retries. A `resume_token` may be sent without information in `partial_rows` to checkpoint the progress of a sparse query. Any previous `partial_rows` data should still be yielded in this case, and the new `resume_token` should be saved for future retries as normal. A `resume_token` will only be sent on a boundary where there is either no ongoing result batch, or `batch_checksum` is also populated. The server will also send a sentinel `resume_token` when last batch of `partial_rows` is sent. If the client retries the ExecuteQueryRequest with the sentinel `resume_token`, the server will emit it again without any data in `partial_rows`, then return OK.", "format": "byte" }, "batchChecksum": { "format": "uint32", "description": "CRC32C checksum of concatenated `partial_rows` data for the current batch. When present, the buffered data from `partial_rows` forms a complete parseable message of the appropriate type. The client should mark the end of a parseable message and prepare to receive a new one starting from the next `PartialResultSet` message. Clients must verify the checksum of the serialized batch before yielding it to the caller. This does NOT mean the values can be yielded to the callers since a `resume_token` is required to safely do so. If `resume_token` is non-empty and any data has been received since the last one, this field is guaranteed to be non-empty. In other words, clients may assume that a batch will never cross a `resume_token` boundary.", "type": "integer" }, "reset": { "description": "If `true`, any data buffered since the last non-empty `resume_token` must be discarded before the other parts of this message, if any, are handled.", "type": "boolean" }, "estimatedBatchSize": { "format": "int32", "type": "integer", "description": "Estimated size of the buffer required to hold the next batch of results. This value will be sent with the first `partial_rows` of a batch. That is, on the first `partial_rows` received in a stream, on the first message after a `batch_checksum` message, and any time `reset` is true. The client can use this estimate to allocate a buffer for the next batch of results. This helps minimize the number of allocations required, though the buffer size may still need to be increased if the estimate is too low." }, "protoRowsBatch": { "$ref": "GoogleBigtableV2..ProtoRowsBatch", "description": "Partial rows in serialized ProtoRows format." } } }, "GoogleBigtableV2..FullReadStatsView": { "properties": { "readIterationStats": { "$ref": "GoogleBigtableV2..ReadIterationStats", "description": "Iteration stats describe how efficient the read is, e.g. comparing rows seen vs. rows returned or cells seen vs cells returned can provide an indication of read efficiency (the higher the ratio of seen to retuned the better)." }, "requestLatencyStats": { "description": "Request latency stats describe the time taken to complete a request, from the server side.", "$ref": "GoogleBigtableV2..RequestLatencyStats" } }, "type": "object", "id": "GoogleBigtableV2..FullReadStatsView", "description": "FullReadStatsView captures all known information about a read." }, "GoogleBigtableV2..OpenAuthorizedViewResponse": { "id": "GoogleBigtableV2..OpenAuthorizedViewResponse", "properties": {}, "type": "object", "description": "Internal usage only." }, "GoogleBigtableV2.SessionMutateRowsRequest.Entry": { "properties": { "idempotency": { "description": "The idempotency of the mutation.", "$ref": "GoogleBigtableV2..Idempotency" }, "key": { "type": "string", "description": "The key of the row to which the `mutations` should be applied.", "format": "byte" }, "mutations": { "type": "array", "items": { "$ref": "GoogleBigtableV2..Mutation" }, "description": "Changes to be atomically applied to the specified row." } }, "type": "object", "description": "A mutation for a given row.", "id": "GoogleBigtableV2.SessionMutateRowsRequest.Entry" }, "GoogleBigtableV2..SessionCheckAndMutateRowRequest": { "properties": { "key": { "type": "string", "format": "byte" }, "predicateFilter": { "$ref": "GoogleBigtableV2..RowFilter" }, "falseMutations": { "items": { "$ref": "GoogleBigtableV2..Mutation" }, "type": "array" }, "trueMutations": { "items": { "$ref": "GoogleBigtableV2..Mutation" }, "type": "array" } }, "type": "object", "id": "GoogleBigtableV2..SessionCheckAndMutateRowRequest", "description": "Internal usage only." }, "GoogleBigtableV2.TypeBytes.Encoding": { "type": "object", "properties": { "raw": { "$ref": "GoogleBigtableV2.TypeBytesEncoding.Raw", "description": "Use `Raw` encoding." } }, "description": "Rules used to convert to or from lower level types.", "id": "GoogleBigtableV2.TypeBytes.Encoding" }, "GoogleBigtableV2..PingAndWarmRequest": { "properties": { "appProfileId": { "type": "string", "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used." } }, "description": "Request message for client connection keep-alive and warming.", "id": "GoogleBigtableV2..PingAndWarmRequest", "type": "object" }, "GoogleBigtableV2.TypeInt32.Encoding": { "description": "Rules used to convert to or from lower level types.", "type": "object", "id": "GoogleBigtableV2.TypeInt32.Encoding", "properties": { "bigEndianBytes": { "$ref": "GoogleBigtableV2.TypeInt32Encoding.BigEndianBytes", "description": "Use `BigEndianBytes` encoding." }, "orderedCodeBytes": { "description": "Use `OrderedCodeBytes` encoding.", "$ref": "GoogleBigtableV2.TypeInt32Encoding.OrderedCodeBytes" } } }, "GoogleBigtableV2.TypeInt64Encoding.OrderedCodeBytes": { "id": "GoogleBigtableV2.TypeInt64Encoding.OrderedCodeBytes", "properties": {}, "type": "object", "description": "Encodes the value in a variable length binary format of up to 10 bytes. Values that are closer to zero use fewer bytes. Sorted mode: all values are supported. Distinct mode: all values are supported." }, "GoogleBigtableV2..ReadRowsRequest": { "properties": { "materializedViewName": { "description": "Optional. The unique name of the MaterializedView from which to read. Values are of the form `projects//instances//materializedViews/`.", "type": "string" }, "tableName": { "description": "Optional. The unique name of the table from which to read. Values are of the form `projects//instances//tables/`.", "type": "string" }, "requestStatsView": { "description": "The view into RequestStats, as described above.", "type": "string", "enumDescriptions": [ "The default / unset value. The API will default to the NONE option below.", "Do not include any RequestStats in the response. This will leave the RequestStats embedded message unset in the response.", "Include the full set of available RequestStats in the response, applicable to this read." ], "enum": [ "REQUEST_STATS_VIEW_UNSPECIFIED", "REQUEST_STATS_NONE", "REQUEST_STATS_FULL" ] }, "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "type": "string" }, "reversed": { "type": "boolean", "description": "Experimental API - Please note that this API is currently experimental and can change in the future. Return rows in lexiographical descending order of the row keys. The row contents will not be affected by this flag. Example result set: [ {key: \"k2\", \"f:col1\": \"v1\", \"f:col2\": \"v1\"}, {key: \"k1\", \"f:col1\": \"v2\", \"f:col2\": \"v2\"} ]" }, "authorizedViewName": { "type": "string", "description": "Optional. The unique name of the AuthorizedView from which to read. Values are of the form `projects//instances//tables//authorizedViews/`." }, "rowsLimit": { "description": "The read will stop after committing to N rows' worth of results. The default (zero) is to return all results.", "format": "int64", "type": "string" }, "rows": { "$ref": "GoogleBigtableV2..RowSet", "description": "The row keys and/or ranges to read sequentially. If not specified, reads from all rows." }, "filter": { "$ref": "GoogleBigtableV2..RowFilter", "description": "The filter to apply to the contents of the specified row(s). If unset, reads the entirety of each row." } }, "id": "GoogleBigtableV2..ReadRowsRequest", "type": "object", "description": "Request message for Bigtable.ReadRows." }, "GoogleBigtableV2.Mutation.DeleteFromRow": { "properties": {}, "id": "GoogleBigtableV2.Mutation.DeleteFromRow", "description": "A Mutation which deletes all cells from the containing row.", "type": "object" }, "GoogleBigtableV2.Type.Map": { "type": "object", "properties": { "valueType": { "$ref": "GoogleBigtableV2..Type", "description": "The type of the values in a map." }, "keyType": { "$ref": "GoogleBigtableV2..Type", "description": "The type of a map key. Only `Bytes`, `String`, and `Int64` are allowed as key types." } }, "description": "A mapping of keys to values of a given type. Values of type `Map` are stored in a `Value.array_value` where each entry is another `Value.array_value` with two elements (the key and the value, in that order). Normally encoded Map values won't have repeated keys, however, clients are expected to handle the case in which they do. If the same key appears multiple times, the _last_ value takes precedence.", "id": "GoogleBigtableV2.Type.Map" }, "GoogleBigtableV2..ExecuteQueryRequest": { "properties": { "protoFormat": { "description": "Protocol buffer format as described by ProtoSchema and ProtoRows messages.", "deprecated": true, "$ref": "GoogleBigtableV2..ProtoFormat" }, "resumeToken": { "format": "byte", "type": "string", "description": "Optional. If this request is resuming a previously interrupted query execution, `resume_token` should be copied from the last PartialResultSet yielded before the interruption. Doing this enables the query execution to resume where the last one left off. The rest of the request parameters must exactly match the request that yielded this token. Otherwise the request will fail." }, "preparedQuery": { "description": "A prepared query that was returned from `PrepareQueryResponse`. Exactly one of `query` and `prepared_query` is required. Setting both or neither is an `INVALID_ARGUMENT`. Setting this field also places restrictions on several other fields: - `data_format` must be empty. - `validate_only` must be false. - `params` must match the `param_types` set in the `PrepareQueryRequest`.", "format": "byte", "type": "string" }, "appProfileId": { "type": "string", "description": "Optional. This value specifies routing for replication. If not specified, the `default` application profile will be used." }, "viewParameters": { "description": "Optional. This map provides the runtime values returned by the VIEW_PARAMETERS() function calls, typically used for user-level scoping of data based on identity. The key is the name of the view parameter e.g. `user_id`, and the value is the parameter value e.g. `alice@example.com`.", "type": "object", "additionalProperties": { "$ref": "GoogleBigtableV2..Value" } }, "params": { "description": "Required. params contains string type keys and Bigtable type values that bind to placeholders in the query string. In query string, a parameter placeholder consists of the `@` character followed by the parameter name (for example, `@firstName`) in the query string. For example, if `params[\"firstName\"] = bytes_value: \"foo\" type {bytes_type {}}` then `@firstName` will be replaced with googlesql bytes value \"foo\" in the query string during query evaluation. If `Value.kind` is not set, the value is treated as a NULL value of the given type. For example, if `params[\"firstName\"] = type {string_type {}}` then `@firstName` will be replaced with googlesql null string. If `query` is set, any empty `Value.type` in the map will be rejected with `INVALID_ARGUMENT`. If `prepared_query` is set, any empty `Value.type` in the map will be inferred from the `param_types` in the `PrepareQueryRequest`. Any non-empty `Value.type` must match the corresponding `param_types` entry, or be rejected with `INVALID_ARGUMENT`.", "type": "object", "additionalProperties": { "$ref": "GoogleBigtableV2..Value" } }, "query": { "description": "Required. The query string. Exactly one of `query` and `prepared_query` is required. Setting both or neither is an `INVALID_ARGUMENT`.", "deprecated": true, "type": "string" } }, "id": "GoogleBigtableV2..ExecuteQueryRequest", "description": "Request message for Bigtable.ExecuteQuery", "type": "object" }, "GoogleBigtableV2.MutateRowsRequest.Entry": { "id": "GoogleBigtableV2.MutateRowsRequest.Entry", "description": "A mutation for a given row.", "type": "object", "properties": { "mutations": { "description": "Required. Changes to be atomically applied to the specified row. Mutations are applied in order, meaning that earlier mutations can be masked by later ones. You must specify at least one mutation.", "type": "array", "items": { "$ref": "GoogleBigtableV2..Mutation" } }, "idempotency": { "$ref": "GoogleBigtableV2..Idempotency", "description": "If set consistently across retries, prevents this mutation from being double applied to aggregate column families within a 15m window." }, "rowKey": { "type": "string", "format": "byte", "description": "The key of the row to which the `mutations` should be applied." } } }, "GoogleBigtableV2..SessionReadRowsResponse": { "description": "Internal usage only.", "properties": { "row": { "items": { "$ref": "GoogleBigtableV2..Row" }, "type": "array" }, "stats": { "$ref": "GoogleBigtableV2..RequestStats" } }, "id": "GoogleBigtableV2..SessionReadRowsResponse", "type": "object" }, "GoogleBigtableV2..MutateRowsResponse": { "description": "Response message for BigtableService.MutateRows.", "type": "object", "id": "GoogleBigtableV2..MutateRowsResponse", "properties": { "entries": { "type": "array", "description": "One or more results for Entries from the batch request.", "items": { "$ref": "GoogleBigtableV2.MutateRowsResponse.Entry" } }, "rateLimitInfo": { "$ref": "GoogleBigtableV2..RateLimitInfo", "description": "Information about how client should limit the rate (QPS). Primirily used by supported official Cloud Bigtable clients. If unset, the rate limit info is not provided by the server." } } }, "GoogleBigtableV2..ExecuteQueryResponse": { "type": "object", "description": "Response message for Bigtable.ExecuteQuery", "properties": { "results": { "description": "A partial result set with row data potentially including additional instructions on how recent past and future partial responses should be interpreted.", "$ref": "GoogleBigtableV2..PartialResultSet" }, "metadata": { "description": "Structure of rows in this response stream. The first (and only the first) response streamed from the server will be of this type.", "$ref": "GoogleBigtableV2..ResultSetMetadata" } }, "id": "GoogleBigtableV2..ExecuteQueryResponse" }, "GoogleBigtableV2.TypeInt64Encoding.BigEndianBytes": { "id": "GoogleBigtableV2.TypeInt64Encoding.BigEndianBytes", "properties": { "bytesType": { "description": "Deprecated: ignored if set.", "$ref": "GoogleBigtableV2.Type.Bytes", "deprecated": true } }, "type": "object", "description": "Encodes the value as an 8-byte big-endian two's complement value. Sorted mode: non-negative values are supported. Distinct mode: all values are supported. Compatible with: - BigQuery `BINARY` encoding - HBase `Bytes.toBytes` - Java `ByteBuffer.putLong()` with `ByteOrder.BIG_ENDIAN`" }, "GoogleBigtableV2.TypeStructEncoding.DelimitedBytes": { "id": "GoogleBigtableV2.TypeStructEncoding.DelimitedBytes", "properties": { "delimiter": { "format": "byte", "description": "Byte sequence used to delimit concatenated fields. The delimiter must contain at least 1 character and at most 50 characters.", "type": "string" } }, "type": "object", "description": "Fields are encoded independently and concatenated with a configurable `delimiter` in between. A struct with no fields defined is encoded as a single `delimiter`. Sorted mode: - Fields are encoded in sorted mode. - Encoded field values must not contain any bytes \u003c= `delimiter[0]` - Element-wise order is preserved: `A \u003c B` if `A[0] \u003c B[0]`, or if `A[0] == B[0] && A[1] \u003c B[1]`, etc. Strict prefixes sort first. - This encoding does not support `DESC` field ordering. Distinct mode: - Fields are encoded in distinct mode. - Encoded field values must not contain `delimiter[0]`." }, "GoogleBigtableV2..ArrayValue": { "description": "`ArrayValue` is an ordered list of `Value`.", "id": "GoogleBigtableV2..ArrayValue", "properties": { "values": { "type": "array", "items": { "$ref": "GoogleBigtableV2..Value" }, "description": "The ordered elements in the array." } }, "type": "object" }, "GoogleBigtableV2..MaterializedViewRequest": { "description": "A request wrapper for operations on a materialized view. Internal usage only.", "id": "GoogleBigtableV2..MaterializedViewRequest", "type": "object", "properties": { "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsRequest" }, "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowRequest" } } }, "GoogleBigtableV2.TypeAggregate.Min": { "type": "object", "properties": {}, "id": "GoogleBigtableV2.TypeAggregate.Min", "description": "Computes the min of the input values. Allowed input: `Int64` State: same as input" }, "GoogleBigtableV2..PingAndWarmResponse": { "properties": {}, "description": "Response message for Bigtable.PingAndWarm connection keepalive and warming.", "id": "GoogleBigtableV2..PingAndWarmResponse", "type": "object" }, "GoogleBigtableV2..TableResponse": { "id": "GoogleBigtableV2..TableResponse", "properties": { "mutateRow": { "$ref": "GoogleBigtableV2..SessionMutateRowResponse" }, "readRow": { "$ref": "GoogleBigtableV2..SessionReadRowResponse" }, "mutateRows": { "$ref": "GoogleBigtableV2..SessionMutateRowsResponse" }, "readRows": { "$ref": "GoogleBigtableV2..SessionReadRowsResponse" }, "checkAndMutateRow": { "$ref": "GoogleBigtableV2..SessionCheckAndMutateRowResponse" }, "readModifyWriteRow": { "$ref": "GoogleBigtableV2..SessionReadModifyWriteRowResponse" } }, "description": "Internal usage only.", "type": "object" }, "GoogleBigtableV2.ReadIterationStats.MemoryLayerStats": { "properties": { "rowResultCounts": { "description": "Number of times a row access attempt resulted in a given outcome. Only contains the very first result for each row.", "additionalProperties": { "type": "string", "format": "int64" }, "type": "object" }, "requestIneligibilityReason": { "description": "Reason why the entire request cannot use the memory layer.", "enumDescriptions": [ "The request was eligible to use the memory layer.", "The client library version is outdated and does not support the memory layer.", "The app profile used for the request does not have a memory layer configured.", "The request was throttled and bypassed the memory layer.", "The rowset in the request is not supported by the memory layer.", "The filter in the request is not supported by the memory layer.", "The memory layer is disabled or unavailable.", "The request was executed with a transaction, which is not supported by the memory layer." ], "type": "string", "enum": [ "REQUEST_ELIGIBLE", "CLIENT_VERSION_OUTDATED", "APP_PROFILE_NO_MEMORY_CONFIG", "REQUEST_THROTTLED", "ROWSET_INELIGIBLE", "FILTER_INELIGIBLE", "MEMORY_LAYER_DISABLED", "TRANSACTIONS_UNSUPPORTED" ] } }, "description": "Captures information about the usage of the memory layer during the read.", "id": "GoogleBigtableV2.ReadIterationStats.MemoryLayerStats", "type": "object" }, "GoogleBigtableV2.TypeStructEncoding.OrderedCodeBytes": { "properties": {}, "description": "Fields are encoded independently, then escaped and delimited by appling the following rules in order: - While the last remaining field is `ASC` or `UNSPECIFIED`, and encodes to the empty string \"\", remove it. - In each remaining field, replace all null bytes `0x00` with the fixed byte pair `{0x00, 0xFF}`. - If any remaining field encodes to the empty string \"\", replace it with the fixed byte pair `{0x00, 0x00}`. - Append the fixed byte pair `{0x00, 0x01}` to each remaining field, except for the last remaining field if it is `ASC`. - Bitwise negate all `DESC` fields. - Concatenate the results, or emit the fixed byte pair `{0x00, 0x00}` if there are no remaining fields to concatenate. Examples: ``` - STRUCT() -\u003e \"\\00\\00\" - STRUCT(\"\") -\u003e \"\\00\\00\" - STRUCT(\"\", \"\") -\u003e \"\\00\\00\" - STRUCT(\"\", \"B\") -\u003e \"\\00\\00\" + \"\\00\\01\" + \"B\" - STRUCT(\"A\", \"\") -\u003e \"A\" - STRUCT(\"\", \"B\", \"\") -\u003e \"\\00\\00\" + \"\\00\\01\" + \"B\" - STRUCT(\"A\", \"\", \"C\") -\u003e \"A\" + \"\\00\\01\" + \"\\00\\00\" + \"\\00\\01\" + \"C\" ``` Examples for struct with `DESC` fields: ``` - STRUCT(\"\" DESC) -\u003e \"\\xFF\\xFF\" + \"\\xFF\\xFE\" - STRUCT(\"\" DESC, \"\") -\u003e \"\\xFF\\xFF\" + \"\\xFF\\xFE\" - STRUCT(\"\" DESC, \"\", \"\") -\u003e \"\\xFF\\xFF\" + \"\\xFF\\xFE\" - STRUCT(\"\" DESC, \"A\") -\u003e \"\\xFF\\xFF\" + \"\\xFF\\xFE\" + \"A\" - STRUCT(\"A\", \"\" DESC, \"\") -\u003e \"A\" + \"\\00\\01\" + \"\\xFF\\xFF\" + \"\\xFF\\xFE\" - STRUCT(\"\", \"A\" DESC) -\u003e \"\\x00\\x00\" + \"\\x00\\x01\" + \"\\xBE\" + \"\\xFF\\xFE\" ``` Since null bytes are always escaped, this encoding can cause size blowup for encodings like `Int64.BigEndianBytes` that are likely to produce many such bytes. Sorted mode: - Fields are encoded in sorted mode. - All values supported by the field encodings are allowed. - Fields with unset or `UNSPECIFIED` order are treated as `ASC`. - Element-wise order is preserved: `A \u003c B` if `A[0] \u003c B[0]`, or if `A[0] == B[0] && A[1] \u003c B[1]`, etc. Strict prefixes sort first. Distinct mode: - Fields are encoded in distinct mode. - All values supported by the field encodings are allowed.", "type": "object", "id": "GoogleBigtableV2.TypeStructEncoding.OrderedCodeBytes" }, "GoogleBigtableV2..ReadChangeStreamRequest": { "id": "GoogleBigtableV2..ReadChangeStreamRequest", "type": "object", "properties": { "continuationTokens": { "$ref": "GoogleBigtableV2..StreamContinuationTokens", "description": "Tokens that describe how to resume reading a stream where reading previously left off. If specified, changes will be read starting at the the position. Tokens are delivered on the stream as part of `Heartbeat` and `CloseStream` messages. If a single token is provided, the token's partition must exactly match the request's partition. If multiple tokens are provided, as in the case of a partition merge, the union of the token partitions must exactly cover the request's partition. Otherwise, INVALID_ARGUMENT will be returned." }, "heartbeatDuration": { "description": "If specified, the duration between `Heartbeat` messages on the stream. Otherwise, defaults to 5 seconds.", "type": "string", "format": "google-duration" }, "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used. Single cluster routing must be configured on the profile.", "type": "string" }, "partition": { "$ref": "GoogleBigtableV2..StreamPartition", "description": "The partition to read changes from." }, "startTime": { "type": "string", "format": "google-datetime", "description": "Start reading the stream at the specified timestamp. This timestamp must be within the change stream retention period, less than or equal to the current time, and after change stream creation, whichever is greater. This value is inclusive and will be truncated to microsecond granularity." }, "endTime": { "description": "If specified, OK will be returned when the stream advances beyond this time. Otherwise, changes will be continuously delivered on the stream. This value is inclusive and will be truncated to microsecond granularity.", "type": "string", "format": "google-datetime" } }, "description": "NOTE: This API is intended to be used by Apache Beam BigtableIO. Request message for Bigtable.ReadChangeStream." }, "GoogleBigtableV2.Type.Array": { "properties": { "elementType": { "description": "The type of the elements in the array. This must not be `Array`.", "$ref": "GoogleBigtableV2..Type" } }, "id": "GoogleBigtableV2.Type.Array", "type": "object", "description": "An ordered list of elements of a given type. Values of type `Array` are stored in `Value.array_value`." } }, "title": "Cloud Bigtable API", "version": "v2", "endpoints": [ { "endpointUrl": "https://bigtable.us-east5.rep.googleapis.com/", "description": "Regional Endpoint", "location": "us-east5" }, { "endpointUrl": "https://bigtable.us-west2.rep.googleapis.com/", "description": "Regional Endpoint", "location": "us-west2" }, { "endpointUrl": "https://bigtable.us-west8.rep.googleapis.com/", "description": "Regional Endpoint", "location": "us-west8" }, { "location": "us-central2", "endpointUrl": "https://bigtable.us-central2.rep.googleapis.com/", "description": "Regional Endpoint" }, { "location": "us-east7", "endpointUrl": "https://bigtable.us-east7.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.us-west1.rep.googleapis.com/", "description": "Regional Endpoint", "location": "us-west1" }, { "location": "us-central1", "endpointUrl": "https://bigtable.us-central1.rep.googleapis.com/", "description": "Regional Endpoint" }, { "location": "us-south1", "endpointUrl": "https://bigtable.us-south1.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.europe-west3.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-west3" }, { "location": "us-east1", "endpointUrl": "https://bigtable.us-east1.rep.googleapis.com/", "description": "Regional Endpoint" }, { "location": "us-east4", "endpointUrl": "https://bigtable.us-east4.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.me-central2.rep.googleapis.com/", "description": "Regional Endpoint", "location": "me-central2" }, { "location": "us-west4", "endpointUrl": "https://bigtable.us-west4.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.us-west3.rep.googleapis.com/", "description": "Regional Endpoint", "location": "us-west3" }, { "location": "europe-west9", "endpointUrl": "https://bigtable.europe-west9.rep.googleapis.com/", "description": "Regional Endpoint" }, { "location": "europe-west8", "endpointUrl": "https://bigtable.europe-west8.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.asia-south2.rep.googleapis.com/", "description": "Regional Endpoint", "location": "asia-south2" }, { "endpointUrl": "https://bigtable.asia-south1.rep.googleapis.com/", "description": "Regional Endpoint", "location": "asia-south1" }, { "endpointUrl": "https://bigtable.asia-southeast3.rep.googleapis.com/", "description": "Regional Endpoint", "location": "asia-southeast3" }, { "endpointUrl": "https://bigtable.northamerica-northeast1.rep.googleapis.com/", "description": "Regional Endpoint", "location": "northamerica-northeast1" }, { "endpointUrl": "https://bigtable.europe-central2.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-central2" }, { "location": "europe-west6", "endpointUrl": "https://bigtable.europe-west6.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.northamerica-northeast2.rep.googleapis.com/", "description": "Regional Endpoint", "location": "northamerica-northeast2" }, { "endpointUrl": "https://bigtable.europe-north1.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-north1" }, { "endpointUrl": "https://bigtable.europe-west1.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-west1" }, { "endpointUrl": "https://bigtable.europe-west4.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-west4" }, { "endpointUrl": "https://bigtable.europe-west10.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-west10" }, { "endpointUrl": "https://bigtable.europe-west12.rep.googleapis.com/", "description": "Regional Endpoint", "location": "europe-west12" }, { "location": "europe-southwest1", "endpointUrl": "https://bigtable.europe-southwest1.rep.googleapis.com/", "description": "Regional Endpoint" }, { "endpointUrl": "https://bigtable.europe-north2.rep.googleapis.com/", "location": "europe-north2", "description": "Regional Endpoint" }, { "location": "europe-west2", "endpointUrl": "https://bigtable.europe-west2.rep.googleapis.com/", "description": "Regional Endpoint" } ], "batchPath": "batch", "discoveryVersion": "v1", "ownerDomain": "google.com", "auth": { "oauth2": { "scopes": { "https://www.googleapis.com/auth/cloud-platform.read-only": { "description": "View your data across Google Cloud services and see the email address of your Google Account" }, "https://www.googleapis.com/auth/cloud-bigtable.data.readonly": { "description": "View the contents of your Cloud Bigtable tables" }, "https://www.googleapis.com/auth/cloud-bigtable.data": { "description": "View and manage the contents of your Cloud Bigtable tables" }, "https://www.googleapis.com/auth/bigtable.data.readonly": { "description": "View the contents of your Cloud Bigtable tables" }, "https://www.googleapis.com/auth/bigtable.data": { "description": "View and manage the contents of your Cloud Bigtable tables" }, "https://www.googleapis.com/auth/cloud-platform": { "description": "See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account." } } } }, "parameters": { "fields": { "type": "string", "location": "query", "description": "Selector specifying which fields to include in a partial response." }, "upload_protocol": { "type": "string", "location": "query", "description": "Upload protocol for media (e.g. \"raw\", \"multipart\")." }, "quotaUser": { "description": "Available to use for quota purposes for server-side applications. Can be any arbitrary string assigned to a user, but should not exceed 40 characters.", "location": "query", "type": "string" }, "callback": { "location": "query", "type": "string", "description": "JSONP" }, "$.xgafv": { "type": "string", "description": "V1 error format.", "location": "query", "enumDescriptions": [ "v1 error format", "v2 error format" ], "enum": [ "1", "2" ] }, "oauth_token": { "description": "OAuth 2.0 token for the current user.", "location": "query", "type": "string" }, "alt": { "enumDescriptions": [ "Responses with Content-Type of application/json", "Media download with context-dependent Content-Type", "Responses with Content-Type of application/x-protobuf" ], "description": "Data format for response.", "enum": [ "json", "media", "proto" ], "default": "json", "type": "string", "location": "query" }, "prettyPrint": { "default": "true", "description": "Returns response with indentations and line breaks.", "type": "boolean", "location": "query" }, "access_token": { "type": "string", "description": "OAuth access token.", "location": "query" }, "uploadType": { "description": "Legacy upload protocol for media (e.g. \"media\", \"multipart\").", "type": "string", "location": "query" }, "key": { "location": "query", "type": "string", "description": "API key. Your API key identifies your project and provides you with API access, quota, and reports. Required unless you provide an OAuth 2.0 token." } }, "revision": "20261025", "rootUrl": "https://bigtable.googleapis.com/", "kind": "discovery#restDescription", "icons": { "x16": "http://www.google.com/images/icons/product/search-16.gif", "x32": "http://www.google.com/images/icons/product/search-32.gif" }, "ownerName": "Google", "id": "bigtable:v2", "protocol": "rest", "basePath": "", "resources": { "projects": { "resources": { "instances": { "methods": { "executeQuery": { "response": { "$ref": "GoogleBigtableV2..ExecuteQueryResponse" }, "description": "Executes a SQL query against a particular Bigtable instance.", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "flatPath": "v2/projects/{projectsId}/instances/{instancesId}:executeQuery", "request": { "$ref": "GoogleBigtableV2..ExecuteQueryRequest" }, "httpMethod": "POST", "id": "bigtable.projects.instances.executeQuery", "path": "v2/{+instanceName}:executeQuery", "parameters": { "instanceName": { "required": true, "pattern": "^projects/[^/]+/instances/[^/]+$", "type": "string", "location": "path", "description": "Required. The unique name of the instance against which the query should be executed. Values are of the form `projects//instances/`" } }, "parameterOrder": [ "instanceName" ] }, "ping": { "parameterOrder": [ "name" ], "request": { "$ref": "GoogleBigtableV2..PingAndWarmRequest" }, "httpMethod": "POST", "response": { "$ref": "GoogleBigtableV2..PingAndWarmResponse" }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}:ping", "path": "v2/{+name}:ping", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "id": "bigtable.projects.instances.ping", "parameters": { "name": { "type": "string", "required": true, "description": "Required. The unique name of the instance to check permissions for as well as respond. Values are of the form `projects//instances/`.", "location": "path", "pattern": "^projects/[^/]+/instances/[^/]+$" } }, "description": "Warm up associated instance metadata for this connection. This call is not required but may be useful for connection keep-alive." }, "prepareQuery": { "parameterOrder": [ "instanceName" ], "flatPath": "v2/projects/{projectsId}/instances/{instancesId}:prepareQuery", "id": "bigtable.projects.instances.prepareQuery", "parameters": { "instanceName": { "description": "Required. The unique name of the instance against which the query should be executed. Values are of the form `projects//instances/`", "type": "string", "location": "path", "required": true, "pattern": "^projects/[^/]+/instances/[^/]+$" } }, "description": "Prepares a GoogleSQL query for execution on a particular Bigtable instance.", "response": { "$ref": "GoogleBigtableV2..PrepareQueryResponse" }, "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "httpMethod": "POST", "path": "v2/{+instanceName}:prepareQuery", "request": { "$ref": "GoogleBigtableV2..PrepareQueryRequest" } } }, "resources": { "tables": { "methods": { "sampleRowKeys": { "response": { "$ref": "GoogleBigtableV2..SampleRowKeysResponse" }, "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ], "parameterOrder": [ "tableName" ], "path": "v2/{+tableName}:sampleRowKeys", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:sampleRowKeys", "httpMethod": "GET", "parameters": { "rowRange.startKeyClosed": { "type": "string", "location": "query", "description": "Used when giving an inclusive lower bound for the range.", "format": "byte" }, "appProfileId": { "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "type": "string", "location": "query" }, "rowRange.startKeyOpen": { "description": "Used when giving an exclusive lower bound for the range.", "type": "string", "format": "byte", "location": "query" }, "authorizedViewName": { "type": "string", "description": "Optional. The unique name of the AuthorizedView from which to sample row keys. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "location": "query" }, "materializedViewName": { "description": "Optional. The unique name of the MaterializedView from which to read. Values are of the form `projects//instances//materializedViews/`.", "type": "string", "location": "query" }, "tableName": { "description": "Optional. The unique name of the table from which to sample row keys. Values are of the form `projects//instances//tables/`.", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "location": "path", "required": true, "type": "string" }, "rowRange.endKeyClosed": { "type": "string", "location": "query", "format": "byte", "description": "Used when giving an inclusive upper bound for the range." }, "rowRange.endKeyOpen": { "description": "Used when giving an exclusive upper bound for the range.", "location": "query", "format": "byte", "type": "string" } }, "description": "Returns a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces. If a `row_range` is provided in the request, the returned samples will be restricted to the specified range.", "id": "bigtable.projects.instances.tables.sampleRowKeys" }, "readModifyWriteRow": { "id": "bigtable.projects.instances.tables.readModifyWriteRow", "description": "Modifies a row atomically on the server. The method reads the latest existing timestamp and value from the specified columns and writes a new entry based on pre-defined read/modify/write rules. The new value for the timestamp is the greater of the existing timestamp or the current server time. The method returns the new contents of all modified cells.", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:readModifyWriteRow", "response": { "$ref": "GoogleBigtableV2..ReadModifyWriteRowResponse" }, "httpMethod": "POST", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "parameters": { "tableName": { "type": "string", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "description": "Optional. The unique name of the table to which the read/modify/write rules should be applied. Values are of the form `projects//instances//tables/`.", "location": "path", "required": true } }, "parameterOrder": [ "tableName" ], "path": "v2/{+tableName}:readModifyWriteRow", "request": { "$ref": "GoogleBigtableV2..ReadModifyWriteRowRequest" } }, "mutateRows": { "path": "v2/{+tableName}:mutateRows", "id": "bigtable.projects.instances.tables.mutateRows", "parameterOrder": [ "tableName" ], "description": "Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically.", "httpMethod": "POST", "response": { "$ref": "GoogleBigtableV2..MutateRowsResponse" }, "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "request": { "$ref": "GoogleBigtableV2..MutateRowsRequest" }, "parameters": { "tableName": { "required": true, "description": "Optional. The unique name of the table to which the mutations should be applied. Values are of the form `projects//instances//tables/`.", "location": "path", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "type": "string" } }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:mutateRows" }, "mutateRow": { "parameterOrder": [ "tableName" ], "httpMethod": "POST", "id": "bigtable.projects.instances.tables.mutateRow", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:mutateRow", "description": "Mutates a row atomically. Cells already present in the row are left unchanged unless explicitly changed by `mutation`.", "path": "v2/{+tableName}:mutateRow", "request": { "$ref": "GoogleBigtableV2..MutateRowRequest" }, "parameters": { "tableName": { "location": "path", "required": true, "description": "Optional. The unique name of the table to which the mutation should be applied. Values are of the form `projects//instances//tables/`.", "type": "string", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$" } }, "response": { "$ref": "GoogleBigtableV2..MutateRowResponse" } }, "readRows": { "id": "bigtable.projects.instances.tables.readRows", "parameterOrder": [ "tableName" ], "httpMethod": "POST", "path": "v2/{+tableName}:readRows", "request": { "$ref": "GoogleBigtableV2..ReadRowsRequest" }, "description": "Streams back the contents of all requested rows in key order, optionally applying the same Reader filter to each. Depending on their size, rows and cells may be broken up across multiple responses, but atomicity of each row will still be preserved. See the ReadRowsResponse documentation for details.", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ], "response": { "$ref": "GoogleBigtableV2..ReadRowsResponse" }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:readRows", "parameters": { "tableName": { "description": "Optional. The unique name of the table from which to read. Values are of the form `projects//instances//tables/`.", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "required": true, "location": "path", "type": "string" } } }, "readChangeStream": { "request": { "$ref": "GoogleBigtableV2..ReadChangeStreamRequest" }, "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "parameters": { "tableName": { "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "description": "Required. The unique name of the table from which to read a change stream. Values are of the form `projects//instances//tables/`. Change streaming must be enabled on the table.", "type": "string", "location": "path", "required": true } }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:readChangeStream", "description": "Reads changes from a table's change stream. Changes will reflect both user-initiated mutations and mutations that are caused by garbage collection. NOTE: This API is only intended to be used by Apache Beam BigtableIO.", "path": "v2/{+tableName}:readChangeStream", "response": { "$ref": "GoogleBigtableV2..ReadChangeStreamResponse" }, "parameterOrder": [ "tableName" ], "id": "bigtable.projects.instances.tables.readChangeStream", "httpMethod": "POST" }, "checkAndMutateRow": { "httpMethod": "POST", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:checkAndMutateRow", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "parameterOrder": [ "tableName" ], "response": { "$ref": "GoogleBigtableV2..CheckAndMutateRowResponse" }, "description": "Mutates a row atomically based on the output of a predicate Reader filter.", "path": "v2/{+tableName}:checkAndMutateRow", "parameters": { "tableName": { "type": "string", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "required": true, "description": "Optional. The unique name of the table to which the conditional mutation should be applied. Values are of the form `projects//instances//tables/`.", "location": "path" } }, "id": "bigtable.projects.instances.tables.checkAndMutateRow", "request": { "$ref": "GoogleBigtableV2..CheckAndMutateRowRequest" } }, "generateInitialChangeStreamPartitions": { "id": "bigtable.projects.instances.tables.generateInitialChangeStreamPartitions", "description": "Returns the current list of partitions that make up the table's change stream. The union of partitions will cover the entire keyspace. Partitions can be read with `ReadChangeStream`. NOTE: This API is only intended to be used by Apache Beam BigtableIO.", "path": "v2/{+tableName}:generateInitialChangeStreamPartitions", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "httpMethod": "POST", "parameterOrder": [ "tableName" ], "response": { "$ref": "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsResponse" }, "parameters": { "tableName": { "required": true, "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+$", "location": "path", "type": "string", "description": "Required. The unique name of the table from which to get change stream partitions. Values are of the form `projects//instances//tables/`. Change streaming must be enabled on the table." } }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}:generateInitialChangeStreamPartitions", "request": { "$ref": "GoogleBigtableV2..GenerateInitialChangeStreamPartitionsRequest" } } }, "resources": { "authorizedViews": { "methods": { "mutateRow": { "path": "v2/{+authorizedViewName}:mutateRow", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:mutateRow", "httpMethod": "POST", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "response": { "$ref": "GoogleBigtableV2..MutateRowResponse" }, "parameterOrder": [ "authorizedViewName" ], "parameters": { "authorizedViewName": { "description": "Optional. The unique name of the AuthorizedView to which the mutation should be applied. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "type": "string", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$", "required": true, "location": "path" } }, "request": { "$ref": "GoogleBigtableV2..MutateRowRequest" }, "id": "bigtable.projects.instances.tables.authorizedViews.mutateRow", "description": "Mutates a row atomically. Cells already present in the row are left unchanged unless explicitly changed by `mutation`." }, "sampleRowKeys": { "response": { "$ref": "GoogleBigtableV2..SampleRowKeysResponse" }, "httpMethod": "GET", "description": "Returns a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces. If a `row_range` is provided in the request, the returned samples will be restricted to the specified range.", "path": "v2/{+authorizedViewName}:sampleRowKeys", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:sampleRowKeys", "parameterOrder": [ "authorizedViewName" ], "id": "bigtable.projects.instances.tables.authorizedViews.sampleRowKeys", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ], "parameters": { "rowRange.startKeyClosed": { "format": "byte", "location": "query", "description": "Used when giving an inclusive lower bound for the range.", "type": "string" }, "rowRange.startKeyOpen": { "format": "byte", "description": "Used when giving an exclusive lower bound for the range.", "location": "query", "type": "string" }, "rowRange.endKeyOpen": { "location": "query", "format": "byte", "type": "string", "description": "Used when giving an exclusive upper bound for the range." }, "materializedViewName": { "description": "Optional. The unique name of the MaterializedView from which to read. Values are of the form `projects//instances//materializedViews/`.", "location": "query", "type": "string" }, "rowRange.endKeyClosed": { "location": "query", "type": "string", "description": "Used when giving an inclusive upper bound for the range.", "format": "byte" }, "tableName": { "description": "Optional. The unique name of the table from which to sample row keys. Values are of the form `projects//instances//tables/`.", "type": "string", "location": "query" }, "appProfileId": { "type": "string", "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "location": "query" }, "authorizedViewName": { "type": "string", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$", "description": "Optional. The unique name of the AuthorizedView from which to sample row keys. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "required": true, "location": "path" } } }, "readRows": { "parameters": { "authorizedViewName": { "required": true, "description": "Optional. The unique name of the AuthorizedView from which to read. Values are of the form `projects//instances//tables//authorizedViews/`.", "location": "path", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$", "type": "string" } }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:readRows", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ], "response": { "$ref": "GoogleBigtableV2..ReadRowsResponse" }, "request": { "$ref": "GoogleBigtableV2..ReadRowsRequest" }, "path": "v2/{+authorizedViewName}:readRows", "id": "bigtable.projects.instances.tables.authorizedViews.readRows", "description": "Streams back the contents of all requested rows in key order, optionally applying the same Reader filter to each. Depending on their size, rows and cells may be broken up across multiple responses, but atomicity of each row will still be preserved. See the ReadRowsResponse documentation for details.", "parameterOrder": [ "authorizedViewName" ], "httpMethod": "POST" }, "readModifyWriteRow": { "parameters": { "authorizedViewName": { "required": true, "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$", "location": "path", "description": "Optional. The unique name of the AuthorizedView to which the read/modify/write rules should be applied. Values are of the form `projects//instances//tables//authorizedViews/`.", "type": "string" } }, "path": "v2/{+authorizedViewName}:readModifyWriteRow", "request": { "$ref": "GoogleBigtableV2..ReadModifyWriteRowRequest" }, "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:readModifyWriteRow", "response": { "$ref": "GoogleBigtableV2..ReadModifyWriteRowResponse" }, "description": "Modifies a row atomically on the server. The method reads the latest existing timestamp and value from the specified columns and writes a new entry based on pre-defined read/modify/write rules. The new value for the timestamp is the greater of the existing timestamp or the current server time. The method returns the new contents of all modified cells.", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "httpMethod": "POST", "id": "bigtable.projects.instances.tables.authorizedViews.readModifyWriteRow", "parameterOrder": [ "authorizedViewName" ] }, "mutateRows": { "httpMethod": "POST", "response": { "$ref": "GoogleBigtableV2..MutateRowsResponse" }, "path": "v2/{+authorizedViewName}:mutateRows", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:mutateRows", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "parameterOrder": [ "authorizedViewName" ], "parameters": { "authorizedViewName": { "location": "path", "required": true, "type": "string", "description": "Optional. The unique name of the AuthorizedView to which the mutations should be applied. Values are of the form `projects//instances//tables/ /authorizedViews/`.", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$" } }, "id": "bigtable.projects.instances.tables.authorizedViews.mutateRows", "description": "Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically.", "request": { "$ref": "GoogleBigtableV2..MutateRowsRequest" } }, "checkAndMutateRow": { "request": { "$ref": "GoogleBigtableV2..CheckAndMutateRowRequest" }, "httpMethod": "POST", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/tables/{tablesId}/authorizedViews/{authorizedViewsId}:checkAndMutateRow", "path": "v2/{+authorizedViewName}:checkAndMutateRow", "parameters": { "authorizedViewName": { "location": "path", "description": "Optional. The unique name of the AuthorizedView to which the conditional mutation should be applied. Values are of the form `projects//instances//tables//authorizedViews/`.", "pattern": "^projects/[^/]+/instances/[^/]+/tables/[^/]+/authorizedViews/[^/]+$", "required": true, "type": "string" } }, "id": "bigtable.projects.instances.tables.authorizedViews.checkAndMutateRow", "description": "Mutates a row atomically based on the output of a predicate Reader filter.", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-platform" ], "parameterOrder": [ "authorizedViewName" ], "response": { "$ref": "GoogleBigtableV2..CheckAndMutateRowResponse" } } } } } }, "materializedViews": { "methods": { "sampleRowKeys": { "parameterOrder": [ "materializedViewName" ], "id": "bigtable.projects.instances.materializedViews.sampleRowKeys", "httpMethod": "GET", "description": "Returns a sample of row keys in the table. The returned row keys will delimit contiguous sections of the table of approximately equal size, which can be used to break up the data for distributed tasks like mapreduces. If a `row_range` is provided in the request, the returned samples will be restricted to the specified range.", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/materializedViews/{materializedViewsId}:sampleRowKeys", "response": { "$ref": "GoogleBigtableV2..SampleRowKeysResponse" }, "parameters": { "rowRange.startKeyClosed": { "location": "query", "type": "string", "description": "Used when giving an inclusive lower bound for the range.", "format": "byte" }, "materializedViewName": { "location": "path", "required": true, "type": "string", "description": "Optional. The unique name of the MaterializedView from which to read. Values are of the form `projects//instances//materializedViews/`.", "pattern": "^projects/[^/]+/instances/[^/]+/materializedViews/[^/]+$" }, "rowRange.endKeyClosed": { "location": "query", "type": "string", "description": "Used when giving an inclusive upper bound for the range.", "format": "byte" }, "tableName": { "description": "Optional. The unique name of the table from which to sample row keys. Values are of the form `projects//instances//tables/`.", "location": "query", "type": "string" }, "rowRange.endKeyOpen": { "location": "query", "type": "string", "format": "byte", "description": "Used when giving an exclusive upper bound for the range." }, "rowRange.startKeyOpen": { "location": "query", "type": "string", "description": "Used when giving an exclusive lower bound for the range.", "format": "byte" }, "appProfileId": { "location": "query", "description": "This value specifies routing for replication. If not specified, the \"default\" application profile will be used.", "type": "string" }, "authorizedViewName": { "type": "string", "location": "query", "description": "Optional. The unique name of the AuthorizedView from which to sample row keys. Values are of the form `projects//instances//tables/ /authorizedViews/`." } }, "path": "v2/{+materializedViewName}:sampleRowKeys", "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ] }, "readRows": { "parameterOrder": [ "materializedViewName" ], "request": { "$ref": "GoogleBigtableV2..ReadRowsRequest" }, "path": "v2/{+materializedViewName}:readRows", "httpMethod": "POST", "response": { "$ref": "GoogleBigtableV2..ReadRowsResponse" }, "parameters": { "materializedViewName": { "pattern": "^projects/[^/]+/instances/[^/]+/materializedViews/[^/]+$", "location": "path", "type": "string", "required": true, "description": "Optional. The unique name of the MaterializedView from which to read. Values are of the form `projects//instances//materializedViews/`." } }, "scopes": [ "https://www.googleapis.com/auth/bigtable.data", "https://www.googleapis.com/auth/bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-bigtable.data", "https://www.googleapis.com/auth/cloud-bigtable.data.readonly", "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/cloud-platform.read-only" ], "id": "bigtable.projects.instances.materializedViews.readRows", "description": "Streams back the contents of all requested rows in key order, optionally applying the same Reader filter to each. Depending on their size, rows and cells may be broken up across multiple responses, but atomicity of each row will still be preserved. See the ReadRowsResponse documentation for details.", "flatPath": "v2/projects/{projectsId}/instances/{instancesId}/materializedViews/{materializedViewsId}:readRows" } } } } } } } }, "name": "bigtable", "description": "API for reading and writing the contents of Bigtable tables associated with a Google Cloud project.", "mtlsRootUrl": "https://bigtable.mtls.googleapis.com/", "baseUrl": "https://bigtable.googleapis.com/", "canonicalName": "Bigtable", "servicePath": "" }