class Google::Cloud::Bigtable::V2::Bigtable::Client

Client for the Bigtable service.

Service for reading from and writing to existing Bigtable tables.

Attributes

bigtable_stub[R]

@private

Public Class Methods

configure() { |configure| ... } click to toggle source

Configure the Bigtable Client class.

See {::Google::Cloud::Bigtable::V2::Bigtable::Client::Configuration} for a description of the configuration fields.

@example

# Modify the configuration for all Bigtable clients
::Google::Cloud::Bigtable::V2::Bigtable::Client.configure do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 56
def self.configure
  @configure ||= begin
    namespace = ["Google", "Cloud", "Bigtable", "V2"]
    parent_config = while namespace.any?
                      parent_name = namespace.join "::"
                      parent_const = const_get parent_name
                      break parent_const.configure if parent_const.respond_to? :configure
                      namespace.pop
                    end
    default_config = Client::Configuration.new parent_config

    default_config.rpcs.read_rows.timeout = 43_200.0
    default_config.rpcs.read_rows.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: []
    }

    default_config.rpcs.sample_row_keys.timeout = 60.0
    default_config.rpcs.sample_row_keys.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: []
    }

    default_config.rpcs.mutate_row.timeout = 60.0
    default_config.rpcs.mutate_row.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: [14, 4]
    }

    default_config.rpcs.mutate_rows.timeout = 600.0
    default_config.rpcs.mutate_rows.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: []
    }

    default_config.rpcs.check_and_mutate_row.timeout = 20.0
    default_config.rpcs.check_and_mutate_row.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: []
    }

    default_config.rpcs.read_modify_write_row.timeout = 20.0
    default_config.rpcs.read_modify_write_row.retry_policy = {
      initial_delay: 0.01, max_delay: 60.0, multiplier: 2, retry_codes: []
    }

    default_config
  end
  yield @configure if block_given?
  @configure
end
new() { |config| ... } click to toggle source

Create a new Bigtable client object.

@example

# Create a client using the default configuration
client = ::Google::Cloud::Bigtable::V2::Bigtable::Client.new

# Create a client using a custom configuration
client = ::Google::Cloud::Bigtable::V2::Bigtable::Client.new do |config|
  config.timeout = 10.0
end

@yield [config] Configure the Bigtable client. @yieldparam config [Client::Configuration]

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 139
def initialize
  # These require statements are intentionally placed here to initialize
  # the gRPC module only when it's required.
  # See https://github.com/googleapis/toolkit/issues/446
  require "gapic/grpc"
  require "google/bigtable/v2/bigtable_services_pb"

  # Create the configuration object
  @config = Configuration.new Client.configure

  # Yield the configuration if needed
  yield @config if block_given?

  # Create credentials
  credentials = @config.credentials
  # Use self-signed JWT if the endpoint is unchanged from default,
  # but only if the default endpoint does not have a region prefix.
  enable_self_signed_jwt = @config.endpoint == Client.configure.endpoint &&
                           !@config.endpoint.split(".").first.include?("-")
  credentials ||= Credentials.default scope: @config.scope,
                                      enable_self_signed_jwt: enable_self_signed_jwt
  if credentials.is_a?(::String) || credentials.is_a?(::Hash)
    credentials = Credentials.new credentials, scope: @config.scope
  end
  @quota_project_id = @config.quota_project
  @quota_project_id ||= credentials.quota_project_id if credentials.respond_to? :quota_project_id

  @bigtable_stub = ::Gapic::ServiceStub.new(
    ::Google::Cloud::Bigtable::V2::Bigtable::Stub,
    credentials:  credentials,
    endpoint:     @config.endpoint,
    channel_args: @config.channel_args,
    interceptors: @config.interceptors
  )
end

Public Instance Methods

check_and_mutate_row(request, options = nil) { |response, operation| ... } click to toggle source

Mutates a row atomically based on the output of a predicate Reader filter.

@overload check_and_mutate_row(request, options = nil)

Pass arguments to `check_and_mutate_row` via a request object, either of type
{::Google::Cloud::Bigtable::V2::CheckAndMutateRowRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::CheckAndMutateRowRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload check_and_mutate_row(table_name: nil, app_profile_id: nil, row_key: nil, predicate_filter: nil, true_mutations: nil, false_mutations: nil)

Pass arguments to `check_and_mutate_row` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::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>`.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.
@param row_key [::String]
  Required. The key of the row to which the conditional mutation should be applied.
@param predicate_filter [::Google::Cloud::Bigtable::V2::RowFilter, ::Hash]
  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.
@param true_mutations [::Array<::Google::Cloud::Bigtable::V2::Mutation, ::Hash>]
  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.
@param false_mutations [::Array<::Google::Cloud::Bigtable::V2::Mutation, ::Hash>]
  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.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Bigtable::V2::CheckAndMutateRowResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Bigtable::V2::CheckAndMutateRowResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 551
def check_and_mutate_row request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::CheckAndMutateRowRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.check_and_mutate_row.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.check_and_mutate_row.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.check_and_mutate_row.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :check_and_mutate_row, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
configure() { |config| ... } click to toggle source

Configure the Bigtable Client instance.

The configuration is set to the derived mode, meaning that values can be changed, but structural changes (adding new fields, etc.) are not allowed. Structural changes should be made on {Client.configure}.

See {::Google::Cloud::Bigtable::V2::Bigtable::Client::Configuration} for a description of the configuration fields.

@yield [config] Configure the Client client. @yieldparam config [Client::Configuration]

@return [Client::Configuration]

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 118
def configure
  yield @config if block_given?
  @config
end
mutate_row(request, options = nil) { |response, operation| ... } click to toggle source

Mutates a row atomically. Cells already present in the row are left unchanged unless explicitly changed by `mutation`.

@overload mutate_row(request, options = nil)

Pass arguments to `mutate_row` via a request object, either of type
{::Google::Cloud::Bigtable::V2::MutateRowRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::MutateRowRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload mutate_row(table_name: nil, app_profile_id: nil, row_key: nil, mutations: nil)

Pass arguments to `mutate_row` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::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>`.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.
@param row_key [::String]
  Required. The key of the row to which the mutation should be applied.
@param mutations [::Array<::Google::Cloud::Bigtable::V2::Mutation, ::Hash>]
  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.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Bigtable::V2::MutateRowResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Bigtable::V2::MutateRowResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 379
def mutate_row request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::MutateRowRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.mutate_row.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.mutate_row.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.mutate_row.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :mutate_row, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
mutate_rows(request, options = nil) { |response, operation| ... } click to toggle source

Mutates multiple rows in a batch. Each individual row is mutated atomically as in MutateRow, but the entire batch is not executed atomically.

@overload mutate_rows(request, options = nil)

Pass arguments to `mutate_rows` via a request object, either of type
{::Google::Cloud::Bigtable::V2::MutateRowsRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::MutateRowsRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload mutate_rows(table_name: nil, app_profile_id: nil, entries: nil)

Pass arguments to `mutate_rows` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::String]
  Required. The unique name of the table to which the mutations should be applied.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.
@param entries [::Array<::Google::Cloud::Bigtable::V2::MutateRowsRequest::Entry, ::Hash>]
  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.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Enumerable<::Google::Cloud::Bigtable::V2::MutateRowsResponse>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Enumerable<::Google::Cloud::Bigtable::V2::MutateRowsResponse>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 458
def mutate_rows request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::MutateRowsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.mutate_rows.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.mutate_rows.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.mutate_rows.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :mutate_rows, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
read_modify_write_row(request, options = nil) { |response, operation| ... } click to toggle source

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.

@overload read_modify_write_row(request, options = nil)

Pass arguments to `read_modify_write_row` via a request object, either of type
{::Google::Cloud::Bigtable::V2::ReadModifyWriteRowRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::ReadModifyWriteRowRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload read_modify_write_row(table_name: nil, app_profile_id: nil, row_key: nil, rules: nil)

Pass arguments to `read_modify_write_row` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::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>`.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.
@param row_key [::String]
  Required. The key of the row to which the read/modify/write rules should be applied.
@param rules [::Array<::Google::Cloud::Bigtable::V2::ReadModifyWriteRule, ::Hash>]
  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.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Google::Cloud::Bigtable::V2::ReadModifyWriteRowResponse] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Google::Cloud::Bigtable::V2::ReadModifyWriteRowResponse]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 635
def read_modify_write_row request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::ReadModifyWriteRowRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.read_modify_write_row.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.read_modify_write_row.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.read_modify_write_row.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :read_modify_write_row, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
read_rows(request, options = nil) { |response, operation| ... } click to toggle source

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.

@overload read_rows(request, options = nil)

Pass arguments to `read_rows` via a request object, either of type
{::Google::Cloud::Bigtable::V2::ReadRowsRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::ReadRowsRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload read_rows(table_name: nil, app_profile_id: nil, rows: nil, filter: nil, rows_limit: nil)

Pass arguments to `read_rows` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::String]
  Required. The unique name of the table from which to read.
  Values are of the form
  `projects/<project>/instances/<instance>/tables/<table>`.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.
@param rows [::Google::Cloud::Bigtable::V2::RowSet, ::Hash]
  The row keys and/or ranges to read. If not specified, reads from all rows.
@param filter [::Google::Cloud::Bigtable::V2::RowFilter, ::Hash]
  The filter to apply to the contents of the specified row(s). If unset,
  reads the entirety of each row.
@param rows_limit [::Integer]
  The read will terminate after committing to N rows' worth of results. The
  default (zero) is to return all results.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Enumerable<::Google::Cloud::Bigtable::V2::ReadRowsResponse>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Enumerable<::Google::Cloud::Bigtable::V2::ReadRowsResponse>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 223
def read_rows request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::ReadRowsRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.read_rows.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.read_rows.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.read_rows.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :read_rows, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end
sample_row_keys(request, options = nil) { |response, operation| ... } click to toggle source

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.

@overload sample_row_keys(request, options = nil)

Pass arguments to `sample_row_keys` via a request object, either of type
{::Google::Cloud::Bigtable::V2::SampleRowKeysRequest} or an equivalent Hash.

@param request [::Google::Cloud::Bigtable::V2::SampleRowKeysRequest, ::Hash]
  A request object representing the call parameters. Required. To specify no
  parameters, or to keep all the default parameter values, pass an empty Hash.
@param options [::Gapic::CallOptions, ::Hash]
  Overrides the default settings for this call, e.g, timeout, retries, etc. Optional.

@overload sample_row_keys(table_name: nil, app_profile_id: nil)

Pass arguments to `sample_row_keys` via keyword arguments. Note that at
least one keyword argument is required. To specify no parameters, or to keep all
the default parameter values, pass an empty Hash as a request object (see above).

@param table_name [::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>`.
@param app_profile_id [::String]
  This value specifies routing for replication. If not specified, the
  "default" application profile will be used.

@yield [response, operation] Access the result along with the RPC operation @yieldparam response [::Enumerable<::Google::Cloud::Bigtable::V2::SampleRowKeysResponse>] @yieldparam operation [::GRPC::ActiveCall::Operation]

@return [::Enumerable<::Google::Cloud::Bigtable::V2::SampleRowKeysResponse>]

@raise [::Google::Cloud::Error] if the RPC is aborted.

# File lib/google/cloud/bigtable/v2/bigtable/client.rb, line 299
def sample_row_keys request, options = nil
  raise ::ArgumentError, "request must be provided" if request.nil?

  request = ::Gapic::Protobuf.coerce request, to: ::Google::Cloud::Bigtable::V2::SampleRowKeysRequest

  # Converts hash and nil to an options object
  options = ::Gapic::CallOptions.new(**options.to_h) if options.respond_to? :to_h

  # Customize the options with defaults
  metadata = @config.rpcs.sample_row_keys.metadata.to_h

  # Set x-goog-api-client and x-goog-user-project headers
  metadata[:"x-goog-api-client"] ||= ::Gapic::Headers.x_goog_api_client \
    lib_name: @config.lib_name, lib_version: @config.lib_version,
    gapic_version: ::Google::Cloud::Bigtable::V2::VERSION
  metadata[:"x-goog-user-project"] = @quota_project_id if @quota_project_id

  header_params = {
    "table_name" => request.table_name
  }
  request_params_header = header_params.map { |k, v| "#{k}=#{v}" }.join("&")
  metadata[:"x-goog-request-params"] ||= request_params_header

  options.apply_defaults timeout:      @config.rpcs.sample_row_keys.timeout,
                         metadata:     metadata,
                         retry_policy: @config.rpcs.sample_row_keys.retry_policy

  options.apply_defaults timeout:      @config.timeout,
                         metadata:     @config.metadata,
                         retry_policy: @config.retry_policy

  @bigtable_stub.call_rpc :sample_row_keys, request, options: options do |response, operation|
    yield response, operation if block_given?
    return response
  end
rescue ::GRPC::BadStatus => e
  raise ::Google::Cloud::Error.from_error(e)
end