Class: MassiveRecord::Wrapper::Row

Inherits:
Object
  • Object
show all
Defined in:
lib/massive_record/wrapper/row.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Row

Returns a new instance of Row.



9
10
11
12
13
14
15
16
 
# File 'lib/massive_record/wrapper/row.rb', line 9

def initialize(opts = {})
  @id              = opts[:id]
  self.values      = opts[:values] || {}
  @table           = opts[:table]
  @column_families = opts[:column_families] || []
  @columns         = opts[:columns] || {}
  @new_record      = true
end

Instance Attribute Details

#column_families ⇒ Object

Returns the value of attribute column_families.



7
8
9
 
# File 'lib/massive_record/wrapper/row.rb', line 7

def column_families
  @column_families
end

#columns ⇒ Object

Returns the value of attribute columns.



7
8
9
 
# File 'lib/massive_record/wrapper/row.rb', line 7

def columns
  @columns
end

#id ⇒ Object

Returns the value of attribute id.



7
8
9
 
# File 'lib/massive_record/wrapper/row.rb', line 7

def id
  @id
end

#new_record ⇒ Object

Returns the value of attribute new_record.



7
8
9
 
# File 'lib/massive_record/wrapper/row.rb', line 7

def new_record
  @new_record
end

#table ⇒ Object

Returns the value of attribute table.



7
8
9
 
# File 'lib/massive_record/wrapper/row.rb', line 7

def table
  @table
end

Class Method Details

.populate_from_trow_result(result, connection, table_name, column_families = []) ⇒ Object 



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/massive_record/wrapper/row.rb', line 139

def self.populate_from_trow_result(result, connection, table_name, column_families = [])
  row                 = self.new
  row.id              = result.row
  row.new_record      = false
  row.table           = Table.new(connection, table_name)
  row.column_families = column_families

  result.columns.each do |name, value|
    row.columns[name] = Cell.new({
      :value      => value.value,
      :created_at => Time.at(value.timestamp / 1000, (value.timestamp % 1000) * 1000)
    })
  end

  row
end

Instance Method Details

#atomic_increment(column_name, by = 1) ⇒ Object

FIXME

The thrift wrapper is only working with strings as far as I can see, and the atomicIncrement call on strings kinda doesn’t make sense on strings

For now I’ll implement this without atomicIncrement, to get the behaviour we want. Guess this in time will either be fixed or raised an not-supported-error. If the latter is the case I guess we’ll need to shift over to a jruby adapter and use the java api instead of thrift.



119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/massive_record/wrapper/row.rb', line 119

def atomic_increment(column_name, by = 1)
  # @table.client.atomicIncrement(@table.name, id.to_s, column_name, by) 
  value_to_increment = @columns[column_name.to_s].value

  raise "Value to increment (#{value_to_increment}) doesnt seem to be a number!" unless value_to_increment =~ /^\d+$/
  raise "Argument by must be an integer" unless by.is_a? Fixnum

  value_to_increment = value_to_increment.to_i
  value_to_increment += by
  value_to_increment = value_to_increment.to_s

  mutation = Apache::Hadoop::Hbase::Thrift::Mutation.new
  mutation.column = column_name
  mutation.value = value_to_increment

  if @table.client.mutateRow(@table.name, id.to_s, [mutation]).nil?
    value_to_increment
  end
end

#column_names ⇒ Object 



18
19
20
 
# File 'lib/massive_record/wrapper/row.rb', line 18

def column_names
  columns.keys
end

#destroy ⇒ Object 



156
157
158
 
# File 'lib/massive_record/wrapper/row.rb', line 156

def destroy
  @table.client.deleteAllRow(@table.name, @id).nil?
end

#fetch_all_column_families ⇒ Object 



22
23
24
25
 
# File 'lib/massive_record/wrapper/row.rb', line 22

def fetch_all_column_families
  @table.fetch_column_family
  fetch_column_families(@table.column_family_names)
end

#fetch_column_families(list) ⇒ Object 



27
28
29
30
31
32
33
34
35
36
37
38
 
# File 'lib/massive_record/wrapper/row.rb', line 27

def fetch_column_families(list)
  @column_families = table.column_families.collect do |column_name, description|
    ColumnFamily.new(column_name.split(":").first, {
      :row          => self,
      :name         => description.name,
      :max_versions => description.maxVersions,
      :compression  => description.compression,
      :in_memory    => description.inMemory
      # bloomFilterType, bloomFilterVectorSize, bloomFilterNbHashes, blockCacheEnabled, timeToLive
    })
  end
end

#merge_columns(data) ⇒ Object

Merge column values with new data : it implies that column values is a JSON encoded string



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/massive_record/wrapper/row.rb', line 69

def merge_columns(data)
  data.each do |column_family_name, columns|
    columns.each do |column_name, values|
      if values.is_a?(Hash)
        unless @columns["#{column_family_name}:#{column_name}"].nil?
          column_value = @columns["#{column_family_name}:#{column_name}"].deserialize_value.merge(values)
        else
          column_value = values
        end            
      elsif values.is_a?(Array)
        unless @columns["#{column_family_name}:#{column_name}"].nil?
          column_value = @columns["#{column_family_name}:#{column_name}"].deserialize_value | values
        else
          column_value = values
        end            
      else
        column_value = values
      end
      update_column(column_family_name, column_name, column_value)
    end
  end
end

#new_record? ⇒ Boolean

Returns:

  • (Boolean) 


160
161
162
 
# File 'lib/massive_record/wrapper/row.rb', line 160

def new_record?
  @new_record
end

#prev ⇒ Object 



164
165
166
 
# File 'lib/massive_record/wrapper/row.rb', line 164

def prev
  self
end

#save ⇒ Object

Parse columns cells and save them



93
94
95
96
97
98
99
100
101
102
103
104
105
 
# File 'lib/massive_record/wrapper/row.rb', line 93

def save
  mutations = []

  @columns.each do |column_name, cell|
    m        = Apache::Hadoop::Hbase::Thrift::Mutation.new
    m.column = column_name
    m.value  = cell.serialized_value
  
    mutations.push(m)
  end

  @table.client.mutateRow(@table.name, id.to_s, mutations).nil?
end

#update_column(column_family_name, column_name, value) ⇒ Object 



58
59
60
61
62
63
64
65
66
 
# File 'lib/massive_record/wrapper/row.rb', line 58

def update_column(column_family_name, column_name, value)
  column = "#{column_family_name}:#{column_name}"

  if @columns[column].nil?
    @columns[column] = Cell.new({ :value => Cell.serialize_value(value), :created_at => Time.now })
  else
    @columns[column].serialize_value(value)
  end
end

#update_columns(data = {}) ⇒ Object 



50
51
52
53
54
55
56
 
# File 'lib/massive_record/wrapper/row.rb', line 50

def update_columns(data = {})
  data.each do |column_family_name, columns|
    columns.each do |column_name, values|
      update_column(column_family_name, column_name, values)
    end
  end
end

#updated_at ⇒ Object 



168
169
170
 
# File 'lib/massive_record/wrapper/row.rb', line 168

def updated_at
  columns.values.collect(&:created_at).max
end

#values ⇒ Object

Parse columns / cells and create a Hash from them



41
42
43
 
# File 'lib/massive_record/wrapper/row.rb', line 41

def values
  @columns.inject({"id" => id}) {|h, (column_name, cell)| h[column_name] = cell.deserialize_value; h}
end

#values=(data) ⇒ Object 



45
46
47
48
 
# File 'lib/massive_record/wrapper/row.rb', line 45

def values=(data)
  @values = {}
  update_columns(data)
end