Module: Arango::DocumentCollection::InstanceMethods

Defined in:
lib/arango/document_collection/instance_methods.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(property, *args, &block) ⇒ Object 



43
44
45
46
47
48
49
 
# File 'lib/arango/document_collection/instance_methods.rb', line 43

def method_missing(property, *args, &block)
  property_s = property.to_s.underscore
  property_y = property_s.to_sym
  return @properties[property_y] = args[0] if property_s.end_with?('=')
  return @properties[property_y] if @properties.key?(property_y)
  super(property, *args, &block)
end

Instance Attribute Details

#database ⇒ Object (readonly)

Returns the value of attribute database.



41
42
43
 
# File 'lib/arango/document_collection/instance_methods.rb', line 41

def database
  @database
end

#graph ⇒ Object (readonly)

Returns the value of attribute graph.



41
42
43
 
# File 'lib/arango/document_collection/instance_methods.rb', line 41

def graph
  @graph
end

#id ⇒ String

Returns:

  • (String) 


52
53
54
55
56
 
# File 'lib/arango/document_collection/instance_methods.rb', line 52

def id
  i = @changed_attributes[:_id] || @attributes[:_id]
  return i if i
  "#{collection.name}/#{key}"
end

#is_system ⇒ Boolean (readonly)

If true, create a system collection. In this case collection-name should start with an underscore. End users should normally create non-system collections only. API implementors may be required to create system collections in very special occasions, but normally a regular collection will do. (The default is false) Can only be set by calling the constructor with the is_system param.

Returns:

  • (Boolean) 


59
60
61
 
# File 'lib/arango/document_collection/instance_methods.rb', line 59

def is_system
  @is_system
end

#name ⇒ String

The name of the collection.

Returns:

  • (String) 


63
64
65
 
# File 'lib/arango/document_collection/instance_methods.rb', line 63

def name
  @name
end

Instance Method Details

#arango_object_id ⇒ String

The collections ArangoDB object_id, not to be confused with the collections ruby object_id.

Returns:

  • (String) 


67
68
69
 
# File 'lib/arango/document_collection/instance_methods.rb', line 67

def arango_object_id
  @properties[:object_id]
end

#checksum(with_revisions: false, with_data: false) ⇒ Object

Returns a checksum for the specified collection

Parameters:

  • with_revisions (Boolean) (defaults to: false) —

    Whether or not to include document revision ids in the checksum calculation, optional, default: false.

  • with_data (Boolean) (defaults to: false) —

    Whether or not to include document body data in the checksum calculation, optional, default: false.



212
213
214
215
216
217
218
219
 
# File 'lib/arango/document_collection/instance_methods.rb', line 212

def checksum (with_revisions: false, with_data: false)
  params = {
    withRevisions: with_revisions,
    withData: with_data
  }
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Checksum.execute(server: server, args: args, params: params).checksum
end

#create ⇒ Arango::DocumentCollection

Stores the collection in the database.

Returns:



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
 
# File 'lib/arango/document_collection/instance_methods.rb', line 128

def create
  @name_changed = false
  @journal_size_changed = false
  @wait_for_sync_changed = false

  body = { name: @name, type: @type }

  @properties.each do |k, v|
    body[k.to_s.camelize(:lower).to_sym] = v unless v.nil?
  end

  if body[:keyOptions]
    body[:keyOptions].delete_if{|_,v| v.nil?}
    body[:keyOptions].transform_keys! { |key| key.to_s.camelize(:lower).to_sym }
  end

  enforce_replication_factor = body.delete(:enforceReplicationFactor)
  wait_for_sync_replication = body.delete(:waitForSyncReplication)

  params = nil
  if enforce_replication_factor || wait_for_sync_replication
    params = {}
    params[:enforceReplicationFactor] = enforce_replication_factor unless enforce_replication_factor.nil?
    params[:waitForSyncReplication] = wait_for_sync_replication unless wait_for_sync_replication.nil?
  end
  result = Arango::Requests::Collection::Create.execute(server: server, body: body, params: params)
  _update_attributes(result)
  self
end

#delete ⇒ NilClass

Deletes a collection.

Returns:

  • (NilClass) 


160
161
162
163
164
 
# File 'lib/arango/document_collection/instance_methods.rb', line 160

def delete
  params = { isSystem: @is_system }
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Delete.execute(server: server, args: args, params: params)
end

#has_more? ⇒ Boolean

Check if more results are available for a cursor

Returns:

  • (Boolean) 


334
335
336
337
 
# File 'lib/arango/document_collection/instance_methods.rb', line 334

def has_more?
  return false unless @cursor
  @cursor[:has_more]
end

#initialize(database: Arango.current_database, graph: nil, name:, id: nil, globally_unique_id: nil, is_system: false, status: nil, type: :document, properties: {}) ⇒ Arango::DocumentCollection

Instantiate a new collection. For param description see the attributes descriptions. All params except name and database are optional.

Parameters:

  • name (String) —

    The name of the collection.

  • type (Symbol) (defaults to: :document)
  • database (Arango::Database) (defaults to: Arango.current_database)
  • status (defaults to: nil)

Returns:



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/arango/document_collection/instance_methods.rb', line 12

def initialize(database: Arango.current_database, graph: nil,
               name:, id: nil, globally_unique_id: nil, is_system: false, status: nil, type: :document,
               properties: {})
  @database = database if database
  @graph = graph if graph
  @cursor = nil
  @batch_proc = nil
  @id = id
  @globally_unique_id = globally_unique_id
  @is_system = is_system
  _set_name(name)
  @name_changed = false
  @original_name = name

  _set_status(status)
  _set_type(type)
  _set_properties(properties)
end

#journal_size=(n) ⇒ Object 



107
108
109
110
 
# File 'lib/arango/document_collection/instance_methods.rb', line 107

def journal_size=(n)
  @journal_size_changed = true
  @properties[:journal_size] = n
end

#key_options ⇒ Arango::Result

Additional options for key generation. If specified, then key_options should be a Hash containing the following attributes:

  • type: specifies the type of the key generator. The currently available generators are traditional, autoincrement, uuid and padded.

  • allow_user_keys: if set to true, then it is allowed to supply own key values in the _key attribute of a document. If set to false, then the key generator will solely be responsible for generating keys and supplying own key values in the _key attribute of documents is considered an error.

  • increment: increment value for autoincrement key generator. Not used for other key generator types.

  • offset: Initial offset value for autoincrement key generator. Not used for other key generator types.

Can only be set by calling the constructor with the key_options param.

Returns:



80
81
82
 
# File 'lib/arango/document_collection/instance_methods.rb', line 80

def key_options
  Arango::Result.new(@properties[:key_options])
end

#load_indexes_into_memory ⇒ Arango::DocumentCollection

Load Indexes into Memory Note: For the time being this function is only useful on RocksDB storage engine, as in MMFiles engine all indexes are in memory anyways.

Returns:



242
243
244
245
246
247
248
 
# File 'lib/arango/document_collection/instance_methods.rb', line 242

def load_indexes_into_memory
  if @database.server.rocksdb?
    args = { name: @name, type: @type }
    Arango::Requests::Collection::LoadIndexesIntoMemory.execute(server: server, args: args)
  end
  self
end

#load_into_memory ⇒ Arango::DocumentCollection

Loads a collection into ArangoDBs memory. Returns the collection on success.

Returns:



223
224
225
226
227
228
 
# File 'lib/arango/document_collection/instance_methods.rb', line 223

def load_into_memory
  args = { name: @name, type: @type, count: false }
  result = Arango::Requests::Collection::Load.execute(server: server, args: args).status
  _set_status(result)
  self
end

#next_batch ⇒ Object

Request next batch from a cursor.

Returns:

  • value depending on original query.



317
318
319
320
321
322
323
324
325
326
327
328
329
330
 
# File 'lib/arango/document_collection/instance_methods.rb', line 317

def next_batch
  return unless has_more?
  @cursor = Arango::Requests::Cursor::NextBatch.execute(server: self.server, args: { id: @cursor[:id] })
  final_result = if @batch_proc
                   @batch_proc.call(@cursor)
                 else
                   @cursor
                 end
  unless @cursor[:has_more]
    @cursor = nil
    @batch_proc = nil
  end
  final_result
end

#recalculate_count ⇒ Arango::DocumentCollection

recalculates the document count of a collection Note: This function is only useful on RocksDB storage engine.

Returns:



264
265
266
267
268
269
270
 
# File 'lib/arango/document_collection/instance_methods.rb', line 264

def recalculate_count
  if @database.server.rocksdb?
    args = { name: @name, type: @type }
    Arango::Requests::Collection::RecalculateCount.execute(server: server, args: args)
  end
  self
end

#reload ⇒ Arango::DocumentCollection Also known as: refresh, revert

Reload collection properties and name from the database, reverting any changes.

Returns:



274
275
276
277
278
279
280
281
282
283
 
# File 'lib/arango/document_collection/instance_methods.rb', line 274

def reload
  request_name = @name_changed ? @original_name : @name
  @name_changed = false
  @journal_size_changed = false
  @wait_for_sync_changed = false
  args = { name: request_name, type: @type }
  result = Arango::Requests::Collection::Get.execute(server: server, args: args)
  _update_attributes(result)
  self
end

#revision ⇒ String

Retrieve the collections revision id

Returns:

  • (String) 


204
205
206
207
 
# File 'lib/arango/document_collection/instance_methods.rb', line 204

def revision
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Revision.execute(server: server, args: args).revision
end

#rotate_journal ⇒ Arango::DocumentCollection

Rotates the journal of a collection. Collection must have a journal. Note: This method is specific for the MMFiles storage engine, and there it is not available in a cluster.

Returns:



253
254
255
256
257
258
259
 
# File 'lib/arango/document_collection/instance_methods.rb', line 253

def rotate_journal
  if @database.server.mmfiles?
    args = { name: @name, type: @type }
    Arango::Requests::Collection::RotateJournal.execute(server: server, args: args)
  end
  self
end

#save ⇒ Arango::DocumentCollection Also known as: update

Save changed collection properties and name changed, to the database. Note: except for wait_for_sync, journal_size and name, collection properties cannot be changed once a collection is created.

Returns:



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

def save
  requests = []
  args = { name: @name, type: @type }
  rename = nil
  if @name_changed
    args[:name] = @original_name
    @name_changed = false
    body = { name: @name }
    rename = Arango::Requests::Collection::Rename.execute(server: server, args: args, body: body)
    @original_name = @name
  end
  if @journal_size_changed || @wait_for_sync_changed
    body = {}
    body[:journalSize] = @journal_size if @journal_size_changed && @database.server.mmfiles?
    body[:waitForSync] = @wait_for_sync if @wait_for_sync_changed
    @journal_size_changed = false
    @wait_for_sync_changed = false
    result = Arango::Requests::Collection::SetProperties.execute(server: server, args: args, body: body)
    @journal_size = result.journal_size if result.key?(:journal_size)
    @wait_for_sync = result.wait_for_sync if result.key?(:wait_for_sync)
  end
  [rename, self]
end

#server ⇒ Object 



122
123
124
 
# File 'lib/arango/document_collection/instance_methods.rb', line 122

def server
  @database.server
end

#shards(details: false) ⇒ Array, Hash

Return the shard ids of a collection Note: This method only works on a cluster coordinator.

Parameters:

  • details (Boolean) (defaults to: false) —

    If set to true, the return value will also contain the responsible servers for the collections’ shards.

Returns:

  • (Array, Hash) 


194
195
196
197
198
199
200
 
# File 'lib/arango/document_collection/instance_methods.rb', line 194

def shards(details: false)
  if @database.server.coordinator?
    args = { name: @name, type: @type }
    body = { details: details }
    Arango::Requests::Collection::Shards.execute(server: server, args: args)
  end
end

#size ⇒ Integer Also known as: count, length

Counts the documents in a collection

Returns:

  • (Integer) 


176
177
178
179
 
# File 'lib/arango/document_collection/instance_methods.rb', line 176

def size
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Count.execute(server: server, args: args).count
end

#statistics ⇒ Hash

Fetch the statistics of a collection

Returns:

  • (Hash) 


185
186
187
188
 
# File 'lib/arango/document_collection/instance_methods.rb', line 185

def statistics
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Statistics.execute(server: server, args: args)
end

#status ⇒ Symbol

The status of the collection as symbol, one of:

  • :unknown

  • :new_born

  • :unloaded

  • :loaded

  • :being_unloaded

  • :deleted

  • :loading

Returns:

  • (Symbol) 


93
94
95
 
# File 'lib/arango/document_collection/instance_methods.rb', line 93

def status
  STATES[@status]
end

#truncate ⇒ Arango::DocumentCollection

Truncates a collection.

Returns:



168
169
170
171
172
 
# File 'lib/arango/document_collection/instance_methods.rb', line 168

def truncate
  args = { name: @name, type: @type }
  Arango::Requests::Collection::Truncate.execute(server: server, args: args)
  self
end

#type ⇒ Symbol

The type of the collection to create. The following values for type are valid:

- document collection, use the :document symbol
- edge collection, use the :edge symbol

The default collection type is :document. Can only be set by calling the constructor with the type param.

Returns:

  • (Symbol) 


103
104
105
 
# File 'lib/arango/document_collection/instance_methods.rb', line 103

def type
  TYPES[@type]
end

#unload_from_memory ⇒ Arango::DocumentCollection

Unloads a collection into ArangoDBs memory. Returns the collection on success.

Returns:



232
233
234
235
236
237
 
# File 'lib/arango/document_collection/instance_methods.rb', line 232

def unload_from_memory
  args = { name: @name, type: @type }
  result = Arango::Requests::Collection::Unload.execute(server: server, args: args).status
  _set_status(result)
  self
end

#wait_for_sync=(n) ⇒ Object 



112
113
114
115
 
# File 'lib/arango/document_collection/instance_methods.rb', line 112

def wait_for_sync=(n)
  @wait_for_sync_changed = true
  @properties[:wait_for_sync] = n
end