Class: Google::Cloud::Bigtable::MutationEntry

Inherits:
Object
  • Object
show all
Defined in:
lib/google/cloud/bigtable/mutation_entry.rb

Overview

MutationEntry

MutationEntry is a chainable structure that holds data for different type of mutations. MutationEntry is used in following data operations:

  • Mutate row. See Table#mutate_row
  • Mutate rows. See Table#mutate_rows
  • Check and mutate row using a predicate. See Table#check_and_mutate_row

Examples:

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
timestamp_micros = (Time.now.to_f * 1000000).round(-3)
entry.set_cell(
  "cf1", "fiel01", "XYZ", timestamp: timestamp_micros
).delete_cells(
  "cf2",
  "field02",
  timestamp_from: timestamp_micros - 5000000,
  timestamp_to: timestamp_micros
).delete_from_family("cf3").delete_from_row

Create using a table.

require "google/cloud/bigtable"

bigtable = Google::Cloud::Bigtable.new
table = bigtable.table("my-instance", "my-table")

entry = table.new_mutation_entry("user-1")
timestamp_micros = (Time.now.to_f * 1000000).round(-3)
entry.set_cell(
  "cf1", "fiel01", "XYZ", timestamp: timestamp_micros
)

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(row_key = nil) ⇒ MutationEntry

Creates a mutation entry instance.

Parameters:

  • row_key (String) (defaults to: nil) 


70
71
72
73
74
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 70

def initialize row_key = nil
  @row_key = row_key
  @mutations = []
  @retryable = true
end

Instance Attribute Details

#row_key ⇒ Object

Returns the value of attribute row_key.



58
59
60
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 58

def row_key
  @row_key
end

Instance Method Details

#delete_cells(family, qualifier, timestamp_from: nil, timestamp_to: nil) ⇒ MutationEntry

Adds a DeleteFromColumn to the list of mutations.

A DeleteFromColumn is a mutation that deletes cells from the specified column, optionally restricting the deletions to a given timestamp range.

Examples:

Without timestamp range.

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
entry.delete_cells("cf-1", "field-1")

With timestamp range.

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
timestamp_micros = (Time.now.to_f * 1000000).round(-3)
entry.delete_cells(
  "cf1",
  "field-1",
  timestamp_from: timestamp_micros - 5000000,
  timestamp_to: timestamp_micros
)

With timestamp range with lower boundary only.

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
timestamp_micros = (Time.now.to_f * 1000000).round(-3)
entry.delete_cells(
  "cf1",
  "field-1",
  timestamp_from: timestamp_micros - 5000000
)

Parameters:

  • family (String) —

    Table column family name. The name of the column family from which cells should be deleted. Must match [-_.a-zA-Z0-9]+

  • qualifier (String) —

    Column qualifier name. The qualifier of the column from which cells should be deleted. Can be any byte string, including an empty string.

  • timestamp_from (Integer) (defaults to: nil) —

    Timestamp lower boundary in microseconds. Optional. Begins the range of timestamps from which cells should be deleted. Values are in microseconds but must match the granularity of the table. Therefore, if Table#granularity is MILLIS (the default), the given value must be a multiple of 1000 (millisecond granularity). For example: 1564257960168000.

  • timestamp_to (Integer) (defaults to: nil) —

    Timestamp upper boundary in microseconds. Optional. Ends the range of timestamps from which cells should be deleted. Values are in microseconds but must match the granularity of the table. Therefore, if Table#granularity is MILLIS (the default), the given value must be a multiple of 1000 (millisecond granularity). For example: 1564257960168000.

Returns:



179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 179

def delete_cells family, qualifier, timestamp_from: nil, timestamp_to: nil
  grpc = Google::Bigtable::V2::Mutation::DeleteFromColumn.new family_name: family, column_qualifier: qualifier
  if timestamp_from || timestamp_to
    time_range = Google::Bigtable::V2::TimestampRange.new
    time_range.start_timestamp_micros = timestamp_from if timestamp_from
    time_range.end_timestamp_micros = timestamp_to if timestamp_to
    grpc.time_range = time_range
  end
  @mutations << Google::Bigtable::V2::Mutation.new(delete_from_column: grpc)
  self
end

#delete_from_family(family) ⇒ MutationEntry

Adds a DeleteFromFamily to the list of mutations.

A DeleteFromFamily is a mutation that deletes all cells from the specified column family.

Examples:

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
entry.delete_from_family("cf-1")

Parameters:

  • family (String) —

    Table column family name. The name of the column family from which cells should be deleted. Must match [-_.a-zA-Z0-9]+

Returns:



205
206
207
208
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 205

def delete_from_family family
  @mutations << Google::Bigtable::V2::Mutation.new(delete_from_family: { family_name: family })
  self
end

#delete_from_row ⇒ MutationEntry

Adds a DeleteFromRow to the list of mutations.

A DeleteFromRow is a mutation which deletes all cells from the containing row.

Examples:

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
entry.delete_from_row

Returns:



221
222
223
224
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 221

def delete_from_row
  @mutations << Google::Bigtable::V2::Mutation.new(delete_from_row: {})
  self
end

#length ⇒ Integer

The number of mutations.

Returns:

  • (Integer) 


240
241
242
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 240

def length
  @mutations.length
end

#retryable? ⇒ Boolean

If the mutation entry is retryable or not based on set_cell value.

Returns:

  • (Boolean) 


231
232
233
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 231

def retryable?
  @retryable
end

#set_cell(family, qualifier, value, timestamp: nil) ⇒ MutationEntry

Adds a SetCell to the list of mutations.

A SetCell is a mutation that sets the value of the specified cell.

Examples:

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
entry.set_cell("cf1", "field01", "XYZ")

With timestamp.

entry = Google::Cloud::Bigtable::MutationEntry.new("user-1")
entry.set_cell(
  "cf-1",
  "field-1",
  "XYZ",
  timestamp: (Time.now.to_f * 1000000).round(-3) # microseconds
)

Parameters:

  • family (String) —

    Table column family name. The name of the family into which new data should be written. Must match [-_.a-zA-Z0-9]+

  • qualifier (String) —

    Column qualifier name. The qualifier of the column into which new data should be written. Can be any byte string, including an empty string.

  • value (String, Integer) —

    Cell value data. The value to be written into the specified cell.

  • timestamp (Integer) (defaults to: nil) —

    Timestamp value in microseconds. 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 are in microseconds but must match the granularity of the table. Therefore, if Table#granularity is MILLIS (the default), the given value must be a multiple of 1000 (millisecond granularity). For example: 1564257960168000.

Returns:



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/google/cloud/bigtable/mutation_entry.rb', line 113

def set_cell family, qualifier, value, timestamp: nil
  # If value is integer, covert it to a 64-bit signed big-endian integer.
  value = [value].pack "q>" if value.is_a? Integer
  options = {
    family_name:      family,
    column_qualifier: qualifier,
    value:            value
  }

  if timestamp
    options[:timestamp_micros] = timestamp
    @retryable = timestamp != -1
  end
  @mutations << Google::Bigtable::V2::Mutation.new(set_cell: options)
  self
end