Class: ActiveRecord::HyperBase

Inherits:
Base
  • Object
show all
Defined in:
lib/hyper_record.rb

Constant Summary collapse

BILLION = 
1_000_000_000.0
ROW_KEY_OFFSET = 
0
COLUMN_FAMILY_OFFSET = 
1
COLUMN_QUALIFIER_OFFSET = 
2
VALUE_OFFSET = 
3
TIMESTAMP_OFFSET = 
4

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

hypertable_connection, inherited, require_hypertable_thrift_client

Constructor Details

#initialize(attrs = {}) ⇒ HyperBase

Returns a new instance of HyperBase.



31
32
33
34
 
# File 'lib/hyper_record.rb', line 31

def initialize(attrs={})
  super(attrs)
  self.ROW = attrs[:ROW] if attrs[:ROW] && attrs[:ROW]
end

Class Attribute Details

.asynchronous_write ⇒ Object

Returns the value of attribute asynchronous_write.



581
582
583
 
# File 'lib/hyper_record.rb', line 581

def asynchronous_write
  @asynchronous_write
end

.mutator ⇒ Object

Returns the value of attribute mutator.



581
582
583
 
# File 'lib/hyper_record.rb', line 581

def mutator
  @mutator
end

.mutator_flags ⇒ Object

Returns the value of attribute mutator_flags.



581
582
583
 
# File 'lib/hyper_record.rb', line 581

def mutator_flags
  @mutator_flags
end

.mutator_flush_interval ⇒ Object

Returns the value of attribute mutator_flush_interval.



581
582
583
 
# File 'lib/hyper_record.rb', line 581

def mutator_flush_interval
  @mutator_flush_interval
end

.qualified_columns ⇒ Object

qualified_column :misc, :qualifiers => [:name, :url]



531
532
533
 
# File 'lib/hyper_record.rb', line 531

def qualified_columns
  @qualified_columns
end

.row_key_attributes(*attrs) ⇒ Object

row_key_attributes :regex => /_(d4-d2-d2_d2:d2)$/, :attribute_names => [:timestamp]



545
546
547
 
# File 'lib/hyper_record.rb', line 545

def row_key_attributes
  @row_key_attributes
end

Class Method Details

.abstract_class? ⇒ Boolean

Returns:

  • (Boolean) 


214
215
216
 
# File 'lib/hyper_record.rb', line 214

def abstract_class?
  self == ActiveRecord::HyperBase
end

.close_mutator(mutator, flush = 0) ⇒ Object

As of Hypertable 0.9.2.5, flush is automatically performed on a close_mutator call (so flush should default to 0).



604
605
606
 
# File 'lib/hyper_record.rb', line 604

def close_mutator(mutator, flush=0)
  self.connection.close_mutator(mutator, flush)
end

.close_scanner(scanner) ⇒ Object 



617
618
619
 
# File 'lib/hyper_record.rb', line 617

def close_scanner(scanner)
  self.connection.close_scanner(scanner)
end

.column_families_without_row_key ⇒ Object 



515
516
517
 
# File 'lib/hyper_record.rb', line 515

def column_families_without_row_key
  columns[1,columns.length]
end

.columns ⇒ Object

Returns array of column objects for table associated with this class.



488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
 
# File 'lib/hyper_record.rb', line 488

def columns
  unless @columns
    @columns = connection.columns(table_name, "#{name} Columns")
    @qualified_columns ||= []
    @qualified_columns.each{|qc|
      # Remove the column family from the column list
      @columns = @columns.reject{|c| c.name == qc[:column_name].to_s}
      connection.remove_column_from_name_map(table_name, qc[:column_name].to_s)

      # Add the new qualified column family to the column list
      @columns << connection.add_qualified_column(table_name, qc[:column_name].to_s, qc[:qualifiers])
    }
    @columns.each {|column| column.primary = column.name == primary_key}
  end
  @columns
end

.convert_cells_to_hashes(cells, options = {}) ⇒ Object

Converts cells that come back from Hypertable into hashes. Each hash represents a separate record (where each cell that has the same row key is considered one record).



372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/hyper_record.rb', line 372

def convert_cells_to_hashes(cells, options={})
  rows = []
  current_row = {}

  # Cells are guaranteed to come back in row key order, so assemble
  # a row by iterating over each cell and checking to see if the row key
  # has changed.  If it has, then the row is complete and needs to be
  # instantiated before processing the next cell.
  cells.each_with_index do |cell, i|
    current_row['ROW'] = cell[ROW_KEY_OFFSET]

    family = connection.rubify_column_name(cell[COLUMN_FAMILY_OFFSET])

    if !cell[COLUMN_QUALIFIER_OFFSET].blank?
      current_row[family] ||= {}
      current_row[family][cell[COLUMN_QUALIFIER_OFFSET]] = cell[VALUE_OFFSET]
    else
      current_row[family] = cell[VALUE_OFFSET]
    end

    # Instantiate the row if we've processed all cells for the row
    next_index = i + 1

    # Check to see if next cell has different row key or if we're at
    # the end of the cell stream.
    if (cells[next_index] and cells[next_index][ROW_KEY_OFFSET] != current_row['ROW']) or next_index >= cells.length
      # Make sure that the resulting object has attributes for all
      # columns - even ones that aren't in the response (due to limited
      # select)

      for col in column_families_without_row_key
        next if options[:instantiate_only_requested_columns] && !options[:select].include?(col.name)

        if !current_row.has_key?(col.name)
          if col.is_a?(ActiveRecord::ConnectionAdapters::QualifiedColumn)
            current_row[col.name] = {}
          else
            current_row[col.name] = nil
          end
        end
      end

      rows << current_row
      current_row = {}
    end
  end

  rows
end

.convert_cells_to_instantiated_rows(cells, options = {}) ⇒ Object 



422
423
424
 
# File 'lib/hyper_record.rb', line 422

def convert_cells_to_instantiated_rows(cells, options={})
  convert_cells_to_hashes(cells, options).map{|row| instantiate(row)}
end

.delete(*ids) ⇒ Object 



229
230
231
 
# File 'lib/hyper_record.rb', line 229

def delete(*ids)
  self.connection.delete_rows(table_name, ids.flatten)
end

.drop_table ⇒ Object 



476
477
478
 
# File 'lib/hyper_record.rb', line 476

def drop_table
  connection.drop_table(table_name) if table_exists?
end

.each_cell(scanner, &block) ⇒ Object

Iterator methods



626
627
628
 
# File 'lib/hyper_record.rb', line 626

def each_cell(scanner, &block)
  self.connection.each_cell(scanner, &block)
end

.each_cell_as_arrays(scanner, &block) ⇒ Object 



630
631
632
 
# File 'lib/hyper_record.rb', line 630

def each_cell_as_arrays(scanner, &block)
  self.connection.each_cell_as_arrays(scanner, &block)
end

.each_row(scanner, &block) ⇒ Object 



634
635
636
 
# File 'lib/hyper_record.rb', line 634

def each_row(scanner, &block)
  self.connection.each_row(scanner, &block)
end

.each_row_as_arrays(scanner, &block) ⇒ Object 



638
639
640
 
# File 'lib/hyper_record.rb', line 638

def each_row_as_arrays(scanner, &block)
  self.connection.each_row_as_arrays(scanner, &block)
end

.exists?(id_or_conditions) ⇒ Boolean

Returns:

  • (Boolean) 


218
219
220
221
222
223
224
225
226
227
 
# File 'lib/hyper_record.rb', line 218

def exists?(id_or_conditions)
  case id_or_conditions
    when Fixnum, String
      !find(:first, :row_keys => [id_or_conditions]).nil?
    when Hash
      !find(:first, :conditions => id_or_conditions).nil?
    else
      raise "only Fixnum, String and Hash arguments supported"
  end
end

.find(*args) ⇒ Object 



233
234
235
236
237
238
239
240
241
 
# File 'lib/hyper_record.rb', line 233

def find(*args)
  options = args.extract_options!

  case args.first
    when :first then find_initial(options)
    when :all   then find_by_options(options)
    else             find_from_ids(args, options)
  end
end

.find_by_hql(hql) ⇒ Object Also known as: find_by_sql

Return the records that match a specific HQL query.



427
428
429
430
431
432
433
434
 
# File 'lib/hyper_record.rb', line 427

def find_by_hql(hql)
  hql_result = connection.execute(hql)
  cells_in_native_array_format = hql_result.cells.map do |c| 
    connection.cell_native_array(c.key.row, c.key.column_family, 
      c.key.column_qualifier, c.value)
  end
  convert_cells_to_instantiated_rows(cells_in_native_array_format)
end

.find_by_options(options) ⇒ Object

Return an array of records matching the finder options.



338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
 
# File 'lib/hyper_record.rb', line 338

def find_by_options(options)
  set_default_options(options)

  # If requested, instead of retrieving the matching cells from
  # Hypertable, simply return a scan spec that matches the finder
  # options.
  if options[:scan_spec]
    return connection.convert_options_to_scan_spec(options)
  end

  cells = connection.execute_with_options(options)

  if HyperBase.log_calls
    msg = [ "Select" ]
    for key in options.keys
      case key
        when :columns
          msg << "  columns\t#{options[:columns].map{|c| c.name}.join(',')}"
        else
          msg << "  #{key}\t#{options[key]}"
      end
    end
    msg << "Returned #{cell_count} cells"

    RAILS_DEFAULT_LOGGER.info(msg)
    # puts msg
  end

  convert_cells_to_instantiated_rows(cells, options)
end

.find_each_row(*args) ⇒ Object

Returns each row matching the finder options as a HyperRecord object. Each object is yielded to the caller so that large queries can be processed one object at a time without pulling the entire result set into memory.

Page.find_each_row(:all) do |page|

...

end



278
279
280
281
282
 
# File 'lib/hyper_record.rb', line 278

def find_each_row(*args)
  find_each_row_as_arrays(*args) do |row|
    yield convert_cells_to_instantiated_rows(row).first
  end
end

.find_each_row_as_arrays(*args) ⇒ Object

Returns each row matching the finder options as an array of cells in native array format. Each row is yielded to the caller so that large queries can be processed one row at a time without pulling the entire result set into memory.

Page.find_each_row(:all) do |page_as_array_of_cells|

...

end



292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
 
# File 'lib/hyper_record.rb', line 292

def find_each_row_as_arrays(*args)
  scan_spec = find_to_scan_spec(*args)
  with_scanner(scan_spec) do |scanner|
    row = []
    current_row_key = nil

    each_cell_as_arrays(scanner) do |cell|
      current_row_key ||= cell[ROW_KEY_OFFSET]

      if cell[ROW_KEY_OFFSET] == current_row_key
        row << cell
      else
        yield row
        row = [cell]
        current_row_key = cell[ROW_KEY_OFFSET]
      end
    end 

    yield row unless row.empty?
  end
end

.find_from_ids(ids, options) ⇒ Object

Return multiple records by row keys.



438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
 
# File 'lib/hyper_record.rb', line 438

def find_from_ids(ids, options)
  expects_array = ids.first.kind_of?(Array)
  return ids.first if expects_array && ids.first.empty?
  ids = ids.flatten.compact.uniq

  case ids.size
    when 0
      raise RecordNotFound, "Couldn't find #{name} without an ID"
    when 1
      result = find_one(ids.first, options)
      expects_array ? [ result ] : result
    else
      find_some(ids, options)
  end
end

.find_initial(options) ⇒ Object

Return the first record that matches the finder options.



327
328
329
330
331
332
333
334
335
 
# File 'lib/hyper_record.rb', line 327

def find_initial(options)
  options.update(:limit => 1)

  if options[:scan_spec]
    find_by_options(options)
  else
    find_by_options(options).first
  end
end

.find_one(id, options) ⇒ Object

Return a single record identified by a row key.



455
456
457
458
459
460
461
462
463
464
465
 
# File 'lib/hyper_record.rb', line 455

def find_one(id, options)
  return nil if id.blank?

  options[:row_keys] = [id.to_s]

  if result = find_initial(options)
    result
  else
    raise ::ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{id}"
  end
end

.find_some(ids, options) ⇒ Object 



467
468
469
470
 
# File 'lib/hyper_record.rb', line 467

def find_some(ids, options)
  options[:row_keys] = [ids.map{|i| i.to_s}]
  find_by_options(options)
end

.find_to_scan_spec(*args) ⇒ Object

Converts incoming finder options into a scan spec. A scan spec is an object used to describe query parameters (columns to retrieve, number of rows to retrieve, row key ranges) for Hypertable queries.



246
247
248
249
250
251
 
# File 'lib/hyper_record.rb', line 246

def find_to_scan_spec(*args)
  options = args.extract_options!
  options[:scan_spec] = true
  args << options
  find(*args)
end

.find_with_scanner(*args, &block) ⇒ Object

Returns a scanner object that allows you to iterate over the result set using the lower-level Thrift client APIs methods that require a scanner object. e.g.,

Page.find_with_scanner(:all, :limit => 1) do |scanner|

Page.each_cell_as_arrays(scanner) do |cell|
  ...
end

end

See the Thrift Client API documentation for more detail. hypertable.org/thrift-api-ref/index.html



265
266
267
268
 
# File 'lib/hyper_record.rb', line 265

def find_with_scanner(*args, &block)
  scan_spec = find_to_scan_spec(*args)
  with_scanner(scan_spec, &block)
end

.flush_mutator(mutator) ⇒ Object 



608
609
610
 
# File 'lib/hyper_record.rb', line 608

def flush_mutator(mutator)
  self.connection.flush_mutator(mutator)
end

.mutator_options(*attrs) ⇒ Object 



584
585
586
587
588
589
590
591
592
593
 
# File 'lib/hyper_record.rb', line 584

def mutator_options(*attrs)
  symbolized_attrs = attrs.first.symbolize_keys
  @mutator_flags = symbolized_attrs[:flags].to_i
  @mutator_flush_interval = symbolized_attrs[:flush_interval].to_i
  @asynchronous_write = symbolized_attrs[:asynchronous_write]

  if symbolized_attrs[:persistent]
    @mutator = self.open_mutator(@mutator_flags, @mutator_flush_interval)
  end
end

.open_mutator(flags = @mutator_flags.to_i, flush_interval = @mutator_flush_interval.to_i) ⇒ Object

Return an open mutator on this table.



598
599
600
 
# File 'lib/hyper_record.rb', line 598

def open_mutator(flags=@mutator_flags.to_i, flush_interval=@mutator_flush_interval.to_i)
  self.connection.open_mutator(table_name, flags, flush_interval)
end

.open_scanner(scan_spec) ⇒ Object

Scanner methods



613
614
615
 
# File 'lib/hyper_record.rb', line 613

def open_scanner(scan_spec)
  self.connection.open_scanner(self.table_name, scan_spec)
end

.primary_key ⇒ Object

Returns the primary key field for a table. In Hypertable, a single row key exists for each row. The row key is referred to as ROW in HQL, so we’ll refer to it the same way here.



483
484
485
 
# File 'lib/hyper_record.rb', line 483

def primary_key
  "ROW"
end

.qualified?(column_name) ⇒ Boolean

Returns:

  • (Boolean) 


505
506
507
 
# File 'lib/hyper_record.rb', line 505

def qualified?(column_name)
  @qualified_columns.map{|c| c[:column_name]}.include?(column_name.to_sym)
end

.qualified_column(*attrs) ⇒ Object 



532
533
534
535
536
537
538
539
540
541
542
 
# File 'lib/hyper_record.rb', line 532

def qualified_column(*attrs)
  @qualified_columns ||= []
  name = attrs.shift

  qualifiers = attrs.shift
  qualifiers = qualifiers.symbolize_keys[:qualifiers] if qualifiers
  @qualified_columns << {
    :column_name => name,
    :qualifiers => qualifiers || []
  }
end

.qualified_column_names_without_row_key ⇒ Object 



519
520
521
522
523
524
525
526
527
528
 
# File 'lib/hyper_record.rb', line 519

def qualified_column_names_without_row_key
  cols = column_families_without_row_key.map{|c| c.name}
  for qc in @qualified_columns
    cols.delete(qc[:column_name].to_s)
    for qualifier in qc[:qualifiers]
      cols << "#{qc[:column_name]}:#{qualifier}"
    end
  end
  cols
end

.quoted_column_names(attributes = attributes_with_quotes) ⇒ Object 



509
510
511
512
513
 
# File 'lib/hyper_record.rb', line 509

def quoted_column_names(attributes=attributes_with_quotes)
  attributes.keys.collect do |column_name|
    self.class.connection.quote_column_name_for_table(column_name, table_name)
  end
end

.set_default_options(options) ⇒ Object

Each hypertable query requires some default options (e.g., table name) that are set here if not specified in the query.



316
317
318
319
320
321
322
323
324
 
# File 'lib/hyper_record.rb', line 316

def set_default_options(options)
  options[:table_name] ||= table_name
  options[:columns] ||= columns

  # Don't request the ROW key explicitly, it always comes back
  options[:select] ||= qualified_column_names_without_row_key.map{|c| 
    connection.hypertable_column_name(c, table_name)
  }
end

.table_exists?(name = table_name) ⇒ Boolean

Returns:

  • (Boolean) 


472
473
474
 
# File 'lib/hyper_record.rb', line 472

def table_exists?(name=table_name)
  connection.tables.include?(name)
end

.with_scanner(scan_spec, &block) ⇒ Object 



621
622
623
 
# File 'lib/hyper_record.rb', line 621

def with_scanner(scan_spec, &block)
  self.connection.with_scanner(self.table_name, scan_spec, &block)
end

.with_thrift_client(&block) ⇒ Object 



642
643
644
 
# File 'lib/hyper_record.rb', line 642

def with_thrift_client(&block)
  self.connection.raw_thrift_client(&block)
end

Instance Method Details

#attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true) ⇒ Object

Returns a copy of the attributes hash where all the values have been safely quoted for insertion. Translates qualified columns from a Hash value in Ruby to a flat list of attributes.

> 
"ROW" => "page_1",
"name" => "name",
"url" => "http://www.icanhascheezburger.com"




135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/hyper_record.rb', line 135

def attributes_with_quotes(include_primary_key = true, include_readonly_attributes = true)
  quoted = attributes.inject({}) do |quoted, (name, value)|
    if column = column_for_attribute(name)
      if column.is_a?(ConnectionAdapters::QualifiedColumn) and value.is_a?(Hash)
        value.keys.each{|k|
          quoted[self.class.connection.qualified_column_name(column.name, k)] = quote_value(value[k], column)
        }
      else
        quoted[name] = quote_value(value, column) unless !include_primary_key && column.primary
      end
    end
    quoted
  end
  include_readonly_attributes ? quoted : remove_readonly_attributes(quoted)
end

#create(mutator = self.class.mutator) ⇒ Object 



43
44
45
46
47
48
 
# File 'lib/hyper_record.rb', line 43

def create(mutator=self.class.mutator)
  write_quoted_attributes(attributes_with_quotes(false, false), 
    self.class.table_name, mutator)
  @new_record = false
  self.attributes[self.class.primary_key]
end

#create_or_update_with_mutator(mutator) ⇒ Object

Raises:

  • (ReadOnlyRecord) 


76
77
78
79
80
 
# File 'lib/hyper_record.rb', line 76

def create_or_update_with_mutator(mutator)
  raise ReadOnlyRecord if readonly?
  result = new_record? ? create(mutator) : update(mutator)
  result != false
end

#decrement(attribute, by = 1) ⇒ Object 



118
119
120
 
# File 'lib/hyper_record.rb', line 118

def decrement(attribute, by=1)
  increment(attribute, -by)
end

#decrement!(attribute, by = 1) ⇒ Object 



122
123
124
 
# File 'lib/hyper_record.rb', line 122

def decrement!(attribute, by=1)
  increment!(attribute, -by)
end

#delete_cells(cells, table = self.class.table_name) ⇒ Object

Delete an array of cells from Hypertable cells is an array of cell keys [[“row”, “column”], …]



193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/hyper_record.rb', line 193

def delete_cells(cells, table=self.class.table_name)
  if HyperBase.log_calls
    msg = [
      "Deleting #{cells.length} cells from #{table} table",
      cells.map{|c| [ c[0], c[1] ].compact.join("\t")}
    ].join("\n")
    RAILS_DEFAULT_LOGGER.info(msg)
    # puts msg
  end

  connection.delete_cells(table, cells)
end

#delete_rows(row_keys, table = self.class.table_name) ⇒ Object

Delete an array of rows from Hypertable rows is an array of row keys [“row1”, “row2”, …]



208
209
210
 
# File 'lib/hyper_record.rb', line 208

def delete_rows(row_keys, table=self.class.table_name)
  connection.delete_rows(table, cells)
end

#destroy ⇒ Object

Destroy an object. Since Hypertable does not have foreign keys, association cells must be removed manually.



84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/hyper_record.rb', line 84

def destroy
  # check for associations and delete association cells as necessary
  for reflection_key in self.class.reflections.keys
    case self.class.reflections[reflection_key].macro
      when :has_and_belongs_to_many
        # remove all the association cells from the associated objects
        cells_to_delete = []

        for row_key in self.send(self.class.reflections[reflection_key].association_foreign_key).keys
          cells_to_delete << connection.cell_native_array(row_key, self.class.reflections[reflection_key].primary_key_name, self.ROW)
        end

        self.delete_cells(cells_to_delete, self.class.reflections[reflection_key].klass.table_name)
    end
  end

  self.class.connection.delete_rows(self.class.table_name, [self.ROW])
end

#increment(attribute, by = 1) ⇒ Object

Casts the attribute to an integer before performing the increment. This is necessary because Hypertable only supports integer types at the moment. The cast has the effect of initializing nil values (and most string values) to zero.



107
108
109
110
111
 
# File 'lib/hyper_record.rb', line 107

def increment(attribute, by=1)
  self[attribute] = self[attribute].to_i
  self[attribute] += by
  self
end

#increment!(attribute, by = 1) ⇒ Object 



113
114
115
116
 
# File 'lib/hyper_record.rb', line 113

def increment!(attribute, by=1)
  increment(attribute, by)
  self.save
end

#quoted_attributes_to_cells(quoted_attrs, table = self.class.table_name) ⇒ Object

Translates the output of attributes_with_quotes into an array of cells suitable for writing into Hypertable (through the write_cells method). Data format is native array format for cells. [

["row_key", "column_family", "column_qualifier", "value"],

]



157
158
159
160
161
162
163
164
165
166
 
# File 'lib/hyper_record.rb', line 157

def quoted_attributes_to_cells(quoted_attrs, table=self.class.table_name)
  cells = []
  pk = self.attributes[self.class.primary_key]

  quoted_attrs.keys.each{|key|
    name, qualifier = connection.hypertable_column_name(key, table).split(':', 2)
    cells << connection.cell_native_array(pk, name, qualifier, quoted_attrs[key])
  }
  cells
end

#save_with_mutator(mutator) ⇒ Object

Allows the save operation to be performed with a specific mutator. By default, a new mutator is opened, flushed and closed for each save operation. Write-heavy application may wish to manually manage mutator flushes (which happens when the mutator is closed) at the application-layer in order to increase write throughput.

m = Page.open_mutator

p1 = Page.new({:ROW => 'created_with_mutator_1', :url => 'url_1'})
p1.save_with_mutator!(m)
p2 = Page.new({:ROW => 'created_with_mutator_2', :url => 'url_2'})
p2.save_with_mutator!(m)

Page.close_mutator(m)

Future versions of hypertable will provide a mutator that automatically periodically flushes. This feature is expected by Summary 2009. At that time, manually managing the mutator at the



68
69
70
 
# File 'lib/hyper_record.rb', line 68

def save_with_mutator(mutator)
  create_or_update_with_mutator(mutator)
end

#save_with_mutator!(mutator) ⇒ Object 



72
73
74
 
# File 'lib/hyper_record.rb', line 72

def save_with_mutator!(mutator)
  create_or_update_with_mutator(mutator) || raise(RecordNotSaved)
end

#update(mutator = self.class.mutator) ⇒ Object

Instance Methods



37
38
39
40
41
 
# File 'lib/hyper_record.rb', line 37

def update(mutator=self.class.mutator)
  write_quoted_attributes(attributes_with_quotes(false, false),
    self.class.table_name, mutator)
  true
end

#write_cells(cells, table = self.class.table_name, mutator = self.class.mutator) ⇒ Object

Write an array of cells to Hypertable



173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/hyper_record.rb', line 173

def write_cells(cells, table=self.class.table_name, mutator=self.class.mutator)
  if HyperBase.log_calls
    msg = [
      "Writing #{cells.length} cells to #{table} table",
      cells.map{|c| [c[0], c[1], c[2], c[3].to_s.first(20)].compact.join("\t")}
    ].join("\n")
    RAILS_DEFAULT_LOGGER.info(msg)
    # puts msg
  end

  connection.write_cells(table, cells, {
    :mutator => mutator, 
    :flags => self.class.mutator_flags, 
    :flush_interval => self.class.mutator_flush_interval,
    :asynchronous_write => self.class.asynchronous_write
  })
end

#write_quoted_attributes(quoted_attrs, table = self.class.table_name, mutator = self.class.mutator) ⇒ Object 



168
169
170
 
# File 'lib/hyper_record.rb', line 168

def write_quoted_attributes(quoted_attrs, table=self.class.table_name, mutator=self.class.mutator)
  write_cells(quoted_attributes_to_cells(quoted_attrs, table), table, mutator)
end