Class: Cassandra::Mock

Inherits:
Object
  • Object
show all
Includes:
Columns, Helpers
Defined in:
lib/cassandra/mock.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Columns

#_standard_counter_mutation, #_super_counter_mutation

Methods included from Helpers

#extract_and_validate_params, #s_map

Constructor Details

#initialize(keyspace, schema) ⇒ Mock

Returns a new instance of Mock.



18
19
20
21
22
23
24
25
26
27
28
 
# File 'lib/cassandra/mock.rb', line 18

def initialize(keyspace, schema)
  @is_super = {}
  @keyspace = keyspace
  @column_name_class = {}
  @sub_column_name_class = {}
  @column_name_maker = {}
  @sub_column_name_maker = {}
  @indexes = {}
  @schema = schema[keyspace]
  clear_keyspace!
end

Instance Attribute Details

#keyspace ⇒ Object (readonly)

Returns the value of attribute keyspace.



16
17
18
 
# File 'lib/cassandra/mock.rb', line 16

def keyspace
  @keyspace
end

Instance Method Details

#add(column_family, key, value, *columns_and_options) ⇒ Object 



342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'lib/cassandra/mock.rb', line 342

def add(column_family, key, value, *columns_and_options)
  if @batch
    @batch << [:add, column_family, key, value, *columns_and_options]
  else
    column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)

    if is_super(column_family)
      cf(column_family)[key]                      ||= OrderedHash.new
      cf(column_family)[key][column]              ||= OrderedHash.new
      cf(column_family)[key][column][sub_column]  ||= 0
      cf(column_family)[key][column][sub_column]  += value
    else
      cf(column_family)[key]                      ||= OrderedHash.new
      cf(column_family)[key][column]              ||= 0
      cf(column_family)[key][column]              += value
    end

    nil
  end
end

#add_column_family(cf) ⇒ Object 



386
387
388
389
390
391
392
 
# File 'lib/cassandra/mock.rb', line 386

def add_column_family(cf)
  @schema[cf.name.to_s] ||= OrderedHash.new

  cf.instance_variables.each do |var|
    @schema[cf.name.to_s][var.slice(1..-1)] = cf.instance_variable_get(var)
  end
end

#batch(options = {}) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/cassandra/mock.rb', line 77

def batch(options={})
  @batch = Cassandra::Batch.new(self, options)
  yield
  flush_batch(options)
ensure
  @batch = nil
end

#clear_column_family!(column_family) ⇒ Object 



37
38
39
 
# File 'lib/cassandra/mock.rb', line 37

def clear_column_family!(column_family)
  @data[column_family.to_sym] = OrderedHash.new
end

#clear_keyspace! ⇒ Object 



33
34
35
 
# File 'lib/cassandra/mock.rb', line 33

def clear_keyspace!
  @data = {}
end

#column_families ⇒ Object 



363
364
365
366
367
368
369
370
371
372
373
374
375
376
 
# File 'lib/cassandra/mock.rb', line 363

def column_families
  cf_defs = {}
  schema.each do |key, value|
    cf_def = Cassandra::ColumnFamily.new

    value.each do |property, property_value|
      cf_def.send(:"#{property}=", property_value)
    end

    cf_defs[key] = cf_def
  end

  cf_defs
end

#column_family_property(column_family, key) ⇒ Object 



382
383
384
 
# File 'lib/cassandra/mock.rb', line 382

def column_family_property(column_family, key)
  schema[column_family.to_s][key]
end

#count_columns(column_family, key, *columns_and_options) ⇒ Object 



196
197
198
199
200
 
# File 'lib/cassandra/mock.rb', line 196

def count_columns(column_family, key, *columns_and_options)
  column_family, columns, sub_columns, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, READ_DEFAULTS)

  get(column_family, key, columns, options).keys.length
end

#count_range(column_family, options = {}) ⇒ Object 



247
248
249
 
# File 'lib/cassandra/mock.rb', line 247

def count_range(column_family, options = {})
  Hash[get_range(column_family, options).select{|k,v| v.length > 0}].keys.compact.length
end

#create_index(ks_name, cf_name, c_name, v_class) ⇒ Object 



278
279
280
281
282
283
284
285
286
287
288
289
 
# File 'lib/cassandra/mock.rb', line 278

def create_index(ks_name, cf_name, c_name, v_class)
  if @indexes[ks_name] &&
    @indexes[ks_name][cf_name] &&
    @indexes[ks_name][cf_name][c_name]
    nil

  else
    @indexes[ks_name] ||= {}
    @indexes[ks_name][cf_name] ||= {}
    @indexes[ks_name][cf_name][c_name] = true
  end
end

#create_index_clause(idx_expressions, start = "", count = 100) ⇒ Object Also known as: create_idx_clause 



307
308
309
 
# File 'lib/cassandra/mock.rb', line 307

def create_index_clause(idx_expressions, start = "", count = 100)
  {:start => start, :index_expressions => idx_expressions, :count => count, :type => :index_clause}
end

#create_index_expression(c_name, value, op) ⇒ Object Also known as: create_idx_expr 



302
303
304
 
# File 'lib/cassandra/mock.rb', line 302

def create_index_expression(c_name, value, op)
  {:column_name => c_name, :value => value, :comparison => op}
end

#default_read_consistency=(value) ⇒ Object 



45
46
47
 
# File 'lib/cassandra/mock.rb', line 45

def default_read_consistency=(value)
  READ_DEFAULTS[:consistency] = value
end

#default_write_consistency=(value) ⇒ Object 



41
42
43
 
# File 'lib/cassandra/mock.rb', line 41

def default_write_consistency=(value)
  WRITE_DEFAULTS[:consistency] = value
end

#disconnect! ⇒ Object 



30
31
 
# File 'lib/cassandra/mock.rb', line 30

def disconnect!
end

#drop_column_family(column_family_name) ⇒ Object 



402
403
404
 
# File 'lib/cassandra/mock.rb', line 402

def drop_column_family(column_family_name)
  @schema.delete(column_family_name)
end

#drop_index(ks_name, cf_name, c_name) ⇒ Object 



291
292
293
294
295
296
297
298
299
300
 
# File 'lib/cassandra/mock.rb', line 291

def drop_index(ks_name, cf_name, c_name)
  if @indexes[ks_name] &&
    @indexes[ks_name][cf_name] &&
    @indexes[ks_name][cf_name][c_name]

    @indexes[ks_name][cf_name].delete(c_name)
  else
    nil
  end
end

#each(column_family, options = {}) ⇒ Object 



257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
 
# File 'lib/cassandra/mock.rb', line 257

def each(column_family, options = {})
  batch_size    = options.delete(:batch_size) || 100
  count         = options.delete(:key_count)
  yielded_count = 0

  options[:start_key] ||= ''
  last_key  = nil

  while options[:start_key] != last_key && (count.nil? || count > yielded_count)
    options[:start_key] = last_key
    res = get_range(column_family, options.merge!(:start_key => last_key, :key_count => batch_size))
    res.each do |key, columns|
      next if options[:start_key] == key
      next if yielded_count == count
      yield key, columns
      yielded_count += 1
      last_key = key
    end
  end
end

#each_key(column_family, options = {}) ⇒ Object 



251
252
253
254
255
 
# File 'lib/cassandra/mock.rb', line 251

def each_key(column_family, options = {})
  each(column_family, options.merge!(:columns => [])) do |key, value|
    yield key
  end
end

#exists?(column_family, key, *columns_and_options) ⇒ Boolean

Returns:

  • (Boolean) 


138
139
140
141
142
143
 
# File 'lib/cassandra/mock.rb', line 138

def exists?(column_family, key, *columns_and_options)
  column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, [key], columns_and_options, READ_DEFAULTS)
  results = get(column_family, key, column, sub_column)

  ![{}, nil].include?(results)
end

#flush_batch(options) ⇒ Object 



85
86
87
88
89
90
91
92
 
# File 'lib/cassandra/mock.rb', line 85

def flush_batch(options)
  b = @batch
  @batch = nil
  b.each do |mutation|
    send(*mutation)
  end
  @batch = b
end

#get(column_family, key, *columns_and_options) ⇒ Object 



94
95
96
97
98
99
100
101
102
 
# File 'lib/cassandra/mock.rb', line 94

def get(column_family, key, *columns_and_options)
  column_family, column, sub_column, options =
    extract_and_validate_params_for_real(column_family, [key], columns_and_options, READ_DEFAULTS)
  if !is_super(column_family)
    get_standard(column_family, key, column, options)
  else
    get_super(column_family, key, column, sub_column, options)
  end
end

#get_columns(column_family, key, *columns_and_options) ⇒ Object 



181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/cassandra/mock.rb', line 181

def get_columns(column_family, key, *columns_and_options)
  column_family, columns, sub_columns, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, READ_DEFAULTS)
  d = get(column_family, key)

  if sub_columns
    sub_columns.collect do |sub_column|
      d[columns][sub_column]
    end
  else
    columns.collect do |column|
      d[column]
    end
  end
end

#get_indexed_slices(column_family, idx_clause, *columns_and_options) ⇒ Object 



312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/cassandra/mock.rb', line 312

def get_indexed_slices(column_family, idx_clause, *columns_and_options)
  column_family, columns, _, options =
    extract_and_validate_params_for_real(column_family, [], columns_and_options,
    READ_DEFAULTS.merge(:key_count => 100, :start_key => nil, :key_start => nil))

  start_key = options[:start_key] || options[:key_start] || ""

  unless [Hash, OrderedHash].include?(idx_clause.class) && idx_clause[:type] == :index_clause
    idx_clause = create_index_clause(idx_clause, start_key, options[:key_count])
  end

  ret = OrderedHash.new
  cf(column_family).each do |key, row|
    next if idx_clause[:start] != '' && key < idx_clause[:start]
    next if ret.length == idx_clause[:count]

    matches = []
    idx_clause[:index_expressions].each do |expr|
      next if row[expr[:column_name]].nil?
      next unless row[expr[:column_name]].send(expr[:comparison].to_sym, expr[:value])

      matches << expr
    end

    ret[key] = row if matches.length == idx_clause[:index_expressions].length
  end

  ret
end

#get_range(column_family, options = {}, &blk) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
 
# File 'lib/cassandra/mock.rb', line 216

def get_range(column_family, options = {}, &blk)
  column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options],
                                                                      READ_DEFAULTS.merge(:start_key  => nil,
                                                                                          :finish_key => nil,
                                                                                          :key_count  => 100,
                                                                                          :columns    => nil,
                                                                                          :reversed   => false
                                                                                         )
                                                                     )
  res = _get_range(column_family,
             options[:start_key],
             options[:finish_key],
             options[:key_count],
             options[:columns],
             options[:start],
             options[:finish],
             options[:count],
             options[:consistency],
             options[:reversed], &blk)

  if blk.nil?
    res
  else
    nil
  end
end

#get_range_keys(column_family, options = {}) ⇒ Object 



243
244
245
 
# File 'lib/cassandra/mock.rb', line 243

def get_range_keys(column_family, options = {})
  get_range(column_family,options.merge!(:columns => [])).keys
end

#get_standard(column_family, key, column, options) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/cassandra/mock.rb', line 104

def get_standard(column_family, key, column, options)
  columns = cf(column_family)[key] || OrderedHash.new
  row = columns_to_hash(column_family, columns)

  if column
    row[column]
  else
    row = apply_range(row, column_family, options[:start], options[:finish])
    row = apply_count(row, options[:count], options[:reversed])
  end
end

#get_super(column_family, key, column, sub_column, options) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/cassandra/mock.rb', line 116

def get_super(column_family, key, column, sub_column, options)
  columns = cf(column_family)[key] || OrderedHash.new
  row = columns_to_hash(column_family, columns)

  if column
    if sub_column
      if row[column] &&
        row[column][sub_column]
        row[column][sub_column]
      else
        nil
      end
    else
      row = row[column] || OrderedHash.new
      row = apply_range(row, column_family, options[:start], options[:finish], false)
      row = apply_count(row, options[:count], options[:reversed])
    end
  else
    row
  end
end

#insert(column_family, key, hash_or_array, options = {}) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/cassandra/mock.rb', line 49

def insert(column_family, key, hash_or_array, options = {})
  if @batch
    @batch << [:insert, column_family, key, hash_or_array, options]
  else
    raise ArgumentError if key.nil?
    if !is_super(column_family)
      insert_standard(column_family, key, hash_or_array)
    else
      insert_super(column_family, key, hash_or_array)
    end
  end
end

#insert_standard(column_family, key, hash_or_array) ⇒ Object 



62
63
64
65
 
# File 'lib/cassandra/mock.rb', line 62

def insert_standard(column_family, key, hash_or_array)
  old = cf(column_family)[key] || OrderedHash.new
  cf(column_family)[key] = merge_and_sort(old, hash_or_array)
end

#insert_super(column_family, key, hash) ⇒ Object

Raises:

  • (ArgumentError) 


67
68
69
70
71
72
73
74
75
 
# File 'lib/cassandra/mock.rb', line 67

def insert_super(column_family, key, hash)
  raise ArgumentError unless hash.is_a?(Hash)
  cf(column_family)[key] ||= OrderedHash.new

  hash.keys.each do |sub_key|
    old = cf(column_family)[key][sub_key] || OrderedHash.new
    cf(column_family)[key][sub_key] = merge_and_sort(old, hash[sub_key])
  end
end

#multi_count_columns(column_family, keys) ⇒ Object 



209
210
211
212
213
214
 
# File 'lib/cassandra/mock.rb', line 209

def multi_count_columns(column_family, keys)
  keys.inject(OrderedHash.new) do |hash, key|
    hash[key] = count_columns(column_family, key)
    hash
  end
end

#multi_get(column_family, keys, *columns_and_options) ⇒ Object 



145
146
147
148
149
150
151
 
# File 'lib/cassandra/mock.rb', line 145

def multi_get(column_family, keys, *columns_and_options)
  column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, keys, columns_and_options, READ_DEFAULTS)
  keys.inject(OrderedHash.new) do |hash, key|
    hash[key] = get(column_family, key)
    hash
  end
end

#multi_get_columns(column_family, keys, columns) ⇒ Object 



202
203
204
205
206
207
 
# File 'lib/cassandra/mock.rb', line 202

def multi_get_columns(column_family, keys, columns)
  keys.inject(OrderedHash.new) do |hash, key|
    hash[key] = get_columns(column_family, key, columns)
    hash
  end
end

#remove(column_family, key, *columns_and_options) ⇒ Object 



153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
 
# File 'lib/cassandra/mock.rb', line 153

def remove(column_family, key, *columns_and_options)
  column_family, columns, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)

  if @batch
    @batch << [:remove, column_family, key, columns, sub_column]
  else
    if columns
      if sub_column
        if columns.is_a? Array
          raise ArgumentError, 'remove does not support sub_columns with array of columns'
        end

        if cf(column_family)[key][columns]
          cf(column_family)[key][columns].delete(sub_column.to_s)
        end
      else
        if cf(column_family)[key]
          Array(columns).each do |column|
            cf(column_family)[key].delete(column.to_s)
          end
        end
      end
    else
      cf(column_family).delete(key)
    end
  end
end

#schema(load = true) ⇒ Object 



378
379
380
 
# File 'lib/cassandra/mock.rb', line 378

def schema(load=true)
  @schema
end

#update_column_family(cf) ⇒ Object 



394
395
396
397
398
399
400
 
# File 'lib/cassandra/mock.rb', line 394

def update_column_family(cf)
  return false unless @schema.include?(cf.name.to_s)

  cf.instance_variables.each do |var|
    @schema[cf.name.to_s][var.slice(1..-1)] = cf.instance_variable_get(var)
  end
end