Class: Cassandra::Mock

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

Instance Method Summary collapse

Methods included from Helpers

#extract_and_validate_params, #s_map

Constructor Details

#initialize(keyspace, schema) ⇒ Mock

Returns a new instance of Mock.



16
17
18
19
20
21
22
23
24
 
# File 'lib/cassandra/mock.rb', line 16

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

Instance Method Details

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



309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/cassandra/mock.rb', line 309

def add(column_family, key, value, *columns_and_options)
  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

#batch ⇒ Object 



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

def batch
  @batch = []
  yield
  b = @batch
  @batch = nil
  b.each do |mutation|
    send(*mutation)
  end
ensure
  @batch = nil
end

#clear_column_family!(column_family) ⇒ Object 



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

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

#clear_keyspace! ⇒ Object 



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

def clear_keyspace!
  @data = {}
end

#column_family_property(column_family, key) ⇒ Object 



330
331
332
 
# File 'lib/cassandra/mock.rb', line 330

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

#count_columns(column_family, key, column = nil) ⇒ Object 



176
177
178
 
# File 'lib/cassandra/mock.rb', line 176

def count_columns(column_family, key, column=nil)
  get(column_family, key, column).keys.length
end

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



217
218
219
 
# File 'lib/cassandra/mock.rb', line 217

def count_range(column_family, options = {})
  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 



248
249
250
251
252
253
254
255
256
257
258
259
 
# File 'lib/cassandra/mock.rb', line 248

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 



277
278
279
 
# File 'lib/cassandra/mock.rb', line 277

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 



272
273
274
 
# File 'lib/cassandra/mock.rb', line 272

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

#default_read_consistency=(value) ⇒ Object 



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

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

#default_write_consistency=(value) ⇒ Object 



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

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

#disconnect! ⇒ Object 



26
27
 
# File 'lib/cassandra/mock.rb', line 26

def disconnect!
end

#drop_index(ks_name, cf_name, c_name) ⇒ Object 



261
262
263
264
265
266
267
268
269
270
 
# File 'lib/cassandra/mock.rb', line 261

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 



227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/cassandra/mock.rb', line 227

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 



221
222
223
224
225
 
# File 'lib/cassandra/mock.rb', line 221

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) 


129
130
131
132
133
134
 
# File 'lib/cassandra/mock.rb', line 129

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

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



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

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 



161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/cassandra/mock.rb', line 161

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 



282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
 
# File 'lib/cassandra/mock.rb', line 282

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, :key_start => ""))

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

  ret = {}
  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 = {}) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/cassandra/mock.rb', line 194

def get_range(column_family, options = {})
  column_family, _, _, options = extract_and_validate_params_for_real(column_family, "", [options], 
                                                                      READ_DEFAULTS.merge(:start_key  => '',
                                                                                          :end_key    => '',
                                                                                          :key_count  => 100,
                                                                                          :columns    => nil
                                                                                         )
                                                                     )
  _get_range(column_family,
             options[:start_key],
             options[:finish_key],
             options[:key_count],
             options[:columns],
             options[:start],
             options[:finish],
             options[:count],
             options[:consistency])
end

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



213
214
215
 
# File 'lib/cassandra/mock.rb', line 213

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

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



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

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])
    apply_count(row, options[:count], options[:reversed])
  end
end

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



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
# File 'lib/cassandra/mock.rb', line 107

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)
      apply_count(row, options[:count], options[:reversed])
    end
  else
    row
  end
end

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



45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/cassandra/mock.rb', line 45

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 



58
59
60
61
 
# File 'lib/cassandra/mock.rb', line 58

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) 


63
64
65
66
67
68
69
70
71
 
# File 'lib/cassandra/mock.rb', line 63

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 



187
188
189
190
191
192
 
# File 'lib/cassandra/mock.rb', line 187

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 



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

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 



180
181
182
183
184
185
 
# File 'lib/cassandra/mock.rb', line 180

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 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/cassandra/mock.rb', line 144

def remove(column_family, key, *columns_and_options)
  column_family, column, sub_column, options = extract_and_validate_params_for_real(column_family, key, columns_and_options, WRITE_DEFAULTS)
  if @batch
    @batch << [:remove, column_family, key, column, sub_column]
  else
    if column
      if sub_column
        cf(column_family)[key][column].delete(sub_column.to_s)
      else
        cf(column_family)[key].delete(column.to_s)
      end
    else
      cf(column_family).delete(key)
    end
  end
end

#schema(load = true) ⇒ Object 



326
327
328
 
# File 'lib/cassandra/mock.rb', line 326

def schema(load=true)
  @schema
end