google-cloud-bigtable 1.3.0

data/lib/google/cloud/bigtable/v2/bigtable_client_config.json

@@ -0,0 +1,83 @@
+{
+  "interfaces": {
+    "google.bigtable.v2.Bigtable": {
+      "retry_codes": {
+        "idempotent": [
+          "DEADLINE_EXCEEDED",
+          "UNAVAILABLE"
+        ],
+        "non_idempotent": []
+      },
+      "retry_params": {
+        "idempotent_params": {
+          "initial_retry_delay_millis": 10,
+          "retry_delay_multiplier": 2.0,
+          "max_retry_delay_millis": 60000,
+          "initial_rpc_timeout_millis": 20000,
+          "rpc_timeout_multiplier": 1.0,
+          "max_rpc_timeout_millis": 20000,
+          "total_timeout_millis": 600000
+        },
+        "non_idempotent_params": {
+          "initial_retry_delay_millis": 10,
+          "retry_delay_multiplier": 2.0,
+          "max_retry_delay_millis": 60000,
+          "initial_rpc_timeout_millis": 20000,
+          "rpc_timeout_multiplier": 1.0,
+          "max_rpc_timeout_millis": 20000,
+          "total_timeout_millis": 20000
+        },
+        "read_rows_params": {
+          "initial_retry_delay_millis": 10,
+          "retry_delay_multiplier": 2.0,
+          "max_retry_delay_millis": 60000,
+          "initial_rpc_timeout_millis": 300000,
+          "rpc_timeout_multiplier": 1.0,
+          "max_rpc_timeout_millis": 300000,
+          "total_timeout_millis": 43200000
+        },
+        "mutate_rows_params": {
+          "initial_retry_delay_millis": 10,
+          "retry_delay_multiplier": 2.0,
+          "max_retry_delay_millis": 60000,
+          "initial_rpc_timeout_millis": 60000,
+          "rpc_timeout_multiplier": 1.0,
+          "max_rpc_timeout_millis": 60000,
+          "total_timeout_millis": 600000
+        }
+      },
+      "methods": {
+        "ReadRows": {
+          "timeout_millis": 43200000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "read_rows_params"
+        },
+        "SampleRowKeys": {
+          "timeout_millis": 60000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "non_idempotent_params"
+        },
+        "MutateRow": {
+          "timeout_millis": 60000,
+          "retry_codes_name": "idempotent",
+          "retry_params_name": "idempotent_params"
+        },
+        "MutateRows": {
+          "timeout_millis": 600000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "mutate_rows_params"
+        },
+        "CheckAndMutateRow": {
+          "timeout_millis": 20000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "non_idempotent_params"
+        },
+        "ReadModifyWriteRow": {
+          "timeout_millis": 20000,
+          "retry_codes_name": "non_idempotent",
+          "retry_params_name": "non_idempotent_params"
+        }
+      }
+    }
+  }
+}

data/lib/google/cloud/bigtable/v2/credentials.rb

@@ -0,0 +1,46 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+require "googleauth"
+
+module Google
+  module Cloud
+    module Bigtable
+      module V2
+        class Credentials < Google::Auth::Credentials
+          SCOPE = [
+            "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"
+          ].freeze
+          PATH_ENV_VARS = %w(BIGTABLE_CREDENTIALS
+                             BIGTABLE_KEYFILE
+                             GOOGLE_CLOUD_CREDENTIALS
+                             GOOGLE_CLOUD_KEYFILE
+                             GCLOUD_KEYFILE)
+          JSON_ENV_VARS = %w(BIGTABLE_CREDENTIALS_JSON
+                             BIGTABLE_KEYFILE_JSON
+                             GOOGLE_CLOUD_CREDENTIALS_JSON
+                             GOOGLE_CLOUD_KEYFILE_JSON
+                             GCLOUD_KEYFILE_JSON)
+          DEFAULT_PATHS = ["~/.config/gcloud/application_default_credentials.json"]
+        end
+      end
+    end
+  end
+end

data/lib/google/cloud/bigtable/v2/doc/google/bigtable/v2/bigtable.rb

@@ -0,0 +1,290 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Bigtable
+    module V2
+      # Request message for Bigtable.ReadRows.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table from which to read.
+      #     Values are of the form
+      #     `projects/<project>/instances/<instance>/tables/<table>`.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      # @!attribute [rw] rows
+      #   @return [Google::Bigtable::V2::RowSet]
+      #     The row keys and/or ranges to read. If not specified, reads from all rows.
+      # @!attribute [rw] filter
+      #   @return [Google::Bigtable::V2::RowFilter]
+      #     The filter to apply to the contents of the specified row(s). If unset,
+      #     reads the entirety of each row.
+      # @!attribute [rw] rows_limit
+      #   @return [Integer]
+      #     The read will terminate after committing to N rows' worth of results. The
+      #     default (zero) is to return all results.
+      class ReadRowsRequest; end
+
+      # Response message for Bigtable.ReadRows.
+      # @!attribute [rw] chunks
+      #   @return [Array<Google::Bigtable::V2::ReadRowsResponse::CellChunk>]
+      #     A collection of a row's contents as part of the read request.
+      # @!attribute [rw] last_scanned_row_key
+      #   @return [String]
+      #     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.
+      class ReadRowsResponse
+        # Specifies a piece of a row's contents returned as part of the read
+        # response stream.
+        # @!attribute [rw] row_key
+        #   @return [String]
+        #     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.
+        # @!attribute [rw] family_name
+        #   @return [Google::Protobuf::StringValue]
+        #     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.
+        # @!attribute [rw] qualifier
+        #   @return [Google::Protobuf::BytesValue]
+        #     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.
+        # @!attribute [rw] timestamp_micros
+        #   @return [Integer]
+        #     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).
+        # @!attribute [rw] labels
+        #   @return [Array<String>]
+        #     Labels applied to the cell by a
+        #     {Google::Bigtable::V2::RowFilter RowFilter}.  Labels are only set
+        #     on the first CellChunk per cell.
+        # @!attribute [rw] value
+        #   @return [String]
+        #     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.
+        # @!attribute [rw] value_size
+        #   @return [Integer]
+        #     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.
+        # @!attribute [rw] reset_row
+        #   @return [true, false]
+        #     Indicates that the client should drop all previous chunks for
+        #     `row_key`, as it will be re-read from the beginning.
+        # @!attribute [rw] commit_row
+        #   @return [true, false]
+        #     Indicates that the client can safely process all previous chunks for
+        #     `row_key`, as its data has been fully read.
+        class CellChunk; end
+      end
+
+      # Request message for Bigtable.SampleRowKeys.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table from which to sample row keys.
+      #     Values are of the form
+      #     `projects/<project>/instances/<instance>/tables/<table>`.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      class SampleRowKeysRequest; end
+
+      # Response message for Bigtable.SampleRowKeys.
+      # @!attribute [rw] row_key
+      #   @return [String]
+      #     Sorted streamed sequence of sample row keys in the table. 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.
+      #     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.
+      # @!attribute [rw] offset_bytes
+      #   @return [Integer]
+      #     Approximate total storage space used by all rows in the table which precede
+      #     `row_key`. Buffering the contents of all rows between two subsequent
+      #     samples would require space roughly equal to the difference in their
+      #     `offset_bytes` fields.
+      class SampleRowKeysResponse; end
+
+      # Request message for Bigtable.MutateRow.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table to which the mutation should be applied.
+      #     Values are of the form
+      #     `projects/<project>/instances/<instance>/tables/<table>`.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      # @!attribute [rw] row_key
+      #   @return [String]
+      #     Required. The key of the row to which the mutation should be applied.
+      # @!attribute [rw] mutations
+      #   @return [Array<Google::Bigtable::V2::Mutation>]
+      #     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.
+      class MutateRowRequest; end
+
+      # Response message for Bigtable.MutateRow.
+      class MutateRowResponse; end
+
+      # Request message for BigtableService.MutateRows.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table to which the mutations should be applied.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      # @!attribute [rw] entries
+      #   @return [Array<Google::Bigtable::V2::MutateRowsRequest::Entry>]
+      #     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.
+      class MutateRowsRequest
+        # A mutation for a given row.
+        # @!attribute [rw] row_key
+        #   @return [String]
+        #     The key of the row to which the `mutations` should be applied.
+        # @!attribute [rw] mutations
+        #   @return [Array<Google::Bigtable::V2::Mutation>]
+        #     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.
+        class Entry; end
+      end
+
+      # Response message for BigtableService.MutateRows.
+      # @!attribute [rw] entries
+      #   @return [Array<Google::Bigtable::V2::MutateRowsResponse::Entry>]
+      #     One or more results for Entries from the batch request.
+      class MutateRowsResponse
+        # The result of applying a passed mutation in the original request.
+        # @!attribute [rw] index
+        #   @return [Integer]
+        #     The index into the original request's `entries` list of the Entry
+        #     for which a result is being reported.
+        # @!attribute [rw] status
+        #   @return [Google::Rpc::Status]
+        #     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.
+        class Entry; end
+      end
+
+      # Request message for Bigtable.CheckAndMutateRow.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table to which the conditional mutation should be
+      #     applied.
+      #     Values are of the form
+      #     `projects/<project>/instances/<instance>/tables/<table>`.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      # @!attribute [rw] row_key
+      #   @return [String]
+      #     Required. The key of the row to which the conditional mutation should be applied.
+      # @!attribute [rw] predicate_filter
+      #   @return [Google::Bigtable::V2::RowFilter]
+      #     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.
+      # @!attribute [rw] true_mutations
+      #   @return [Array<Google::Bigtable::V2::Mutation>]
+      #     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.
+      # @!attribute [rw] false_mutations
+      #   @return [Array<Google::Bigtable::V2::Mutation>]
+      #     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.
+      class CheckAndMutateRowRequest; end
+
+      # Response message for Bigtable.CheckAndMutateRow.
+      # @!attribute [rw] predicate_matched
+      #   @return [true, false]
+      #     Whether or not the request's `predicate_filter` yielded any results for
+      #     the specified row.
+      class CheckAndMutateRowResponse; end
+
+      # Request message for Bigtable.ReadModifyWriteRow.
+      # @!attribute [rw] table_name
+      #   @return [String]
+      #     Required. The unique name of the table to which the read/modify/write rules should be
+      #     applied.
+      #     Values are of the form
+      #     `projects/<project>/instances/<instance>/tables/<table>`.
+      # @!attribute [rw] app_profile_id
+      #   @return [String]
+      #     This value specifies routing for replication. If not specified, the
+      #     "default" application profile will be used.
+      # @!attribute [rw] row_key
+      #   @return [String]
+      #     Required. The key of the row to which the read/modify/write rules should be applied.
+      # @!attribute [rw] rules
+      #   @return [Array<Google::Bigtable::V2::ReadModifyWriteRule>]
+      #     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.
+      class ReadModifyWriteRowRequest; end
+
+      # Response message for Bigtable.ReadModifyWriteRow.
+      # @!attribute [rw] row
+      #   @return [Google::Bigtable::V2::Row]
+      #     A Row containing the new contents of all cells modified by the request.
+      class ReadModifyWriteRowResponse; end
+    end
+  end
+end

data/lib/google/cloud/bigtable/v2/doc/google/bigtable/v2/data.rb

@@ -0,0 +1,493 @@
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+module Google
+  module Bigtable
+    module V2
+      # Specifies the complete (requested) contents of a single row of a table.
+      # Rows which exceed 256MiB in size cannot be read in full.
+      # @!attribute [rw] key
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] families
+      #   @return [Array<Google::Bigtable::V2::Family>]
+      #     May be empty, but only if the entire row is empty.
+      #     The mutual ordering of column families is not specified.
+      class Row; end
+
+      # Specifies (some of) the contents of a single row/column family intersection
+      # of a table.
+      # @!attribute [rw] name
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] columns
+      #   @return [Array<Google::Bigtable::V2::Column>]
+      #     Must not be empty. Sorted in order of increasing "qualifier".
+      class Family; end
+
+      # Specifies (some of) the contents of a single row/column intersection of a
+      # table.
+      # @!attribute [rw] qualifier
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] cells
+      #   @return [Array<Google::Bigtable::V2::Cell>]
+      #     Must not be empty. Sorted in order of decreasing "timestamp_micros".
+      class Column; end
+
+      # Specifies (some of) the contents of a single row/column/timestamp of a table.
+      # @!attribute [rw] timestamp_micros
+      #   @return [Integer]
+      #     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.
+      # @!attribute [rw] value
+      #   @return [String]
+      #     The value stored in the cell.
+      #     May contain any byte string, including the empty string, up to 100MiB in
+      #     length.
+      # @!attribute [rw] labels
+      #   @return [Array<String>]
+      #     Labels applied to the cell by a {Google::Bigtable::V2::RowFilter RowFilter}.
+      class Cell; end
+
+      # Specifies a contiguous range of rows.
+      # @!attribute [rw] start_key_closed
+      #   @return [String]
+      #     Used when giving an inclusive lower bound for the range.
+      # @!attribute [rw] start_key_open
+      #   @return [String]
+      #     Used when giving an exclusive lower bound for the range.
+      # @!attribute [rw] end_key_open
+      #   @return [String]
+      #     Used when giving an exclusive upper bound for the range.
+      # @!attribute [rw] end_key_closed
+      #   @return [String]
+      #     Used when giving an inclusive upper bound for the range.
+      class RowRange; end
+
+      # Specifies a non-contiguous set of rows.
+      # @!attribute [rw] row_keys
+      #   @return [Array<String>]
+      #     Single rows included in the set.
+      # @!attribute [rw] row_ranges
+      #   @return [Array<Google::Bigtable::V2::RowRange>]
+      #     Contiguous row ranges included in the set.
+      class RowSet; end
+
+      # Specifies a contiguous range of columns within a single column family.
+      # The range spans from &lt;column_family&gt;:&lt;start_qualifier&gt; to
+      # &lt;column_family&gt;:&lt;end_qualifier&gt;, where both bounds can be either
+      # inclusive or exclusive.
+      # @!attribute [rw] family_name
+      #   @return [String]
+      #     The name of the column family within which this range falls.
+      # @!attribute [rw] start_qualifier_closed
+      #   @return [String]
+      #     Used when giving an inclusive lower bound for the range.
+      # @!attribute [rw] start_qualifier_open
+      #   @return [String]
+      #     Used when giving an exclusive lower bound for the range.
+      # @!attribute [rw] end_qualifier_closed
+      #   @return [String]
+      #     Used when giving an inclusive upper bound for the range.
+      # @!attribute [rw] end_qualifier_open
+      #   @return [String]
+      #     Used when giving an exclusive upper bound for the range.
+      class ColumnRange; end
+
+      # Specified a contiguous range of microsecond timestamps.
+      # @!attribute [rw] start_timestamp_micros
+      #   @return [Integer]
+      #     Inclusive lower bound. If left empty, interpreted as 0.
+      # @!attribute [rw] end_timestamp_micros
+      #   @return [Integer]
+      #     Exclusive upper bound. If left empty, interpreted as infinity.
+      class TimestampRange; end
+
+      # Specifies a contiguous range of raw byte values.
+      # @!attribute [rw] start_value_closed
+      #   @return [String]
+      #     Used when giving an inclusive lower bound for the range.
+      # @!attribute [rw] start_value_open
+      #   @return [String]
+      #     Used when giving an exclusive lower bound for the range.
+      # @!attribute [rw] end_value_closed
+      #   @return [String]
+      #     Used when giving an inclusive upper bound for the range.
+      # @!attribute [rw] end_value_open
+      #   @return [String]
+      #     Used when giving an exclusive upper bound for the range.
+      class ValueRange; end
+
+      # 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 4096 bytes, and RowFilters may not be nested within each other
+      # (in Chains or Interleaves) to a depth of more than 20.
+      # @!attribute [rw] chain
+      #   @return [Google::Bigtable::V2::RowFilter::Chain]
+      #     Applies several RowFilters to the data in sequence, progressively
+      #     narrowing the results.
+      # @!attribute [rw] interleave
+      #   @return [Google::Bigtable::V2::RowFilter::Interleave]
+      #     Applies several RowFilters to the data in parallel and combines the
+      #     results.
+      # @!attribute [rw] condition
+      #   @return [Google::Bigtable::V2::RowFilter::Condition]
+      #     Applies one of two possible RowFilters to the data based on the output of
+      #     a predicate RowFilter.
+      # @!attribute [rw] sink
+      #   @return [true, false]
+      #     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 {Google::Bigtable::V2::RowFilter::Interleave 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 {Google::Bigtable::V2::RowFilter::Condition Condition}.
+      # @!attribute [rw] pass_all_filter
+      #   @return [true, false]
+      #     Matches all cells, regardless of input. Functionally equivalent to
+      #     leaving `filter` unset, but included for completeness.
+      # @!attribute [rw] block_all_filter
+      #   @return [true, false]
+      #     Does not match any cells, regardless of input. Useful for temporarily
+      #     disabling just part of a filter.
+      # @!attribute [rw] row_key_regex_filter
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] row_sample_filter
+      #   @return [Float]
+      #     Matches all cells from a row with probability p, and matches no cells
+      #     from the row with probability 1-p.
+      # @!attribute [rw] family_name_regex_filter
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] column_qualifier_regex_filter
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] column_range_filter
+      #   @return [Google::Bigtable::V2::ColumnRange]
+      #     Matches only cells from columns within the given range.
+      # @!attribute [rw] timestamp_range_filter
+      #   @return [Google::Bigtable::V2::TimestampRange]
+      #     Matches only cells with timestamps within the given range.
+      # @!attribute [rw] value_regex_filter
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] value_range_filter
+      #   @return [Google::Bigtable::V2::ValueRange]
+      #     Matches only cells with values that fall within the given range.
+      # @!attribute [rw] cells_per_row_offset_filter
+      #   @return [Integer]
+      #     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.
+      # @!attribute [rw] cells_per_row_limit_filter
+      #   @return [Integer]
+      #     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.
+      # @!attribute [rw] cells_per_column_limit_filter
+      #   @return [Integer]
+      #     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.
+      # @!attribute [rw] strip_value_transformer
+      #   @return [true, false]
+      #     Replaces each cell's value with the empty string.
+      # @!attribute [rw] apply_label_transformer
+      #   @return [String]
+      #     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.
+      class RowFilter
+        # A RowFilter which sends rows through several RowFilters in sequence.
+        # @!attribute [rw] filters
+        #   @return [Array<Google::Bigtable::V2::RowFilter>]
+        #     The elements of "filters" are chained together to process the input row:
+        #     in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
+        #     The full chain is executed atomically.
+        class Chain; end
+
+        # A RowFilter which sends each row to each of several component
+        # RowFilters and interleaves the results.
+        # @!attribute [rw] filters
+        #   @return [Array<Google::Bigtable::V2::RowFilter>]
+        #     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.
+        class Interleave; end
+
+        # 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.
+        # @!attribute [rw] predicate_filter
+        #   @return [Google::Bigtable::V2::RowFilter]
+        #     If `predicate_filter` outputs any cells, then `true_filter` will be
+        #     evaluated on the input row. Otherwise, `false_filter` will be evaluated.
+        # @!attribute [rw] true_filter
+        #   @return [Google::Bigtable::V2::RowFilter]
+        #     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.
+        # @!attribute [rw] false_filter
+        #   @return [Google::Bigtable::V2::RowFilter]
+        #     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.
+        class Condition; end
+      end
+
+      # Specifies a particular change to be made to the contents of a row.
+      # @!attribute [rw] set_cell
+      #   @return [Google::Bigtable::V2::Mutation::SetCell]
+      #     Set a cell's value.
+      # @!attribute [rw] delete_from_column
+      #   @return [Google::Bigtable::V2::Mutation::DeleteFromColumn]
+      #     Deletes cells from a column.
+      # @!attribute [rw] delete_from_family
+      #   @return [Google::Bigtable::V2::Mutation::DeleteFromFamily]
+      #     Deletes cells from a column family.
+      # @!attribute [rw] delete_from_row
+      #   @return [Google::Bigtable::V2::Mutation::DeleteFromRow]
+      #     Deletes cells from the entire row.
+      class Mutation
+        # A Mutation which sets the value of the specified cell.
+        # @!attribute [rw] family_name
+        #   @return [String]
+        #     The name of the family into which new data should be written.
+        #     Must match `[-_.a-zA-Z0-9]+`
+        # @!attribute [rw] column_qualifier
+        #   @return [String]
+        #     The qualifier of the column into which new data should be written.
+        #     Can be any byte string, including the empty string.
+        # @!attribute [rw] timestamp_micros
+        #   @return [Integer]
+        #     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).
+        # @!attribute [rw] value
+        #   @return [String]
+        #     The value to be written into the specified cell.
+        class SetCell; end
+
+        # A Mutation which deletes cells from the specified column, optionally
+        # restricting the deletions to a given timestamp range.
+        # @!attribute [rw] family_name
+        #   @return [String]
+        #     The name of the family from which cells should be deleted.
+        #     Must match `[-_.a-zA-Z0-9]+`
+        # @!attribute [rw] column_qualifier
+        #   @return [String]
+        #     The qualifier of the column from which cells should be deleted.
+        #     Can be any byte string, including the empty string.
+        # @!attribute [rw] time_range
+        #   @return [Google::Bigtable::V2::TimestampRange]
+        #     The range of timestamps within which cells should be deleted.
+        class DeleteFromColumn; end
+
+        # A Mutation which deletes all cells from the specified column family.
+        # @!attribute [rw] family_name
+        #   @return [String]
+        #     The name of the family from which cells should be deleted.
+        #     Must match `[-_.a-zA-Z0-9]+`
+        class DeleteFromFamily; end
+
+        # A Mutation which deletes all cells from the containing row.
+        class DeleteFromRow; end
+      end
+
+      # Specifies an atomic read/modify/write operation on the latest value of the
+      # specified column.
+      # @!attribute [rw] family_name
+      #   @return [String]
+      #     The name of the family to which the read/modify/write should be applied.
+      #     Must match `[-_.a-zA-Z0-9]+`
+      # @!attribute [rw] column_qualifier
+      #   @return [String]
+      #     The qualifier of the column to which the read/modify/write should be
+      #     applied.
+      #     Can be any byte string, including the empty string.
+      # @!attribute [rw] append_value
+      #   @return [String]
+      #     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.
+      # @!attribute [rw] increment_amount
+      #   @return [Integer]
+      #     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.
+      class ReadModifyWriteRule; end
+    end
+  end
+end