Module: Arango::EdgeCollection::InstanceMethods

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

Overview

Arango EdgeCollection InstanceMethods

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 



36
37
38
39
40
41
42
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 36

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

Returns the value of attribute database.



33
34
35
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 33

def database
  @database
end

#graph ⇒ Object (readonly)

Returns the value of attribute graph.



34
35
36
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 34

def graph
  @graph
end

#id ⇒ String (readonly)

Returns:



45
46
47
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 45

def id
  @id
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:



52
53
54
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 52

def is_system
  @is_system
end

#name ⇒ String

The name of the collection.

Returns:



56
57
58
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 56

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:



60
61
62
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 60

def arango_object_id
  @properties[:object_id]
end

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

Returns a checksum for the specified collection

Parameters:

  • (defaults to: false)

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

  • (defaults to: false)

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



206
207
208
209
210
211
212
213
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 206

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

#create ⇒ Arango::DocumentCollection

Stores the collection in the database.

Returns:

  • self



121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 121

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:



154
155
156
157
158
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 154

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 betched request.

Returns:



328
329
330
331
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 328

def has_more?
  return false unless @aql
  @aql.has_more?
end

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

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

Parameters:

  • The name of the collection.

  • (defaults to: :edge)
  • (defaults to: Arango.current_database)
  • (defaults to: nil)

Returns:



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

def initialize(database: Arango.current_database, graph: nil,
               name:, id: nil, globally_unique_id: nil, is_system: false, status: nil, type: :edge,
               properties: {})
  send(:database=, database) if database
  send(:graph=, graph) if graph
  @aql = 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 



100
101
102
103
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 100

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:



73
74
75
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 73

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:

  • self



236
237
238
239
240
241
242
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 236

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:

  • self



217
218
219
220
221
222
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 217

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 batched request.

Returns:

  • value depending on original batched request.



311
312
313
314
315
316
317
318
319
320
321
322
323
324
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 311

def next_batch
  return unless has_more?
  result = @aql.next
  final_result = if @batch_proc
                   @batch_proc.call(result)
                 else
                   result
                 end
  unless @aql.has_more?
    @aql = 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:

  • self



258
259
260
261
262
263
264
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 258

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:

  • self



268
269
270
271
272
273
274
275
276
277
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 268

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:



198
199
200
201
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 198

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:

  • self



247
248
249
250
251
252
253
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 247

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:

  • self



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

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 



115
116
117
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 115

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:

  • (defaults to: false)

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

Returns:



189
190
191
192
193
194
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 189

def shards(details: false)
  return nil unless @database.server.coordinator?
  args = { name: @name, type: @type }
  params = { details: details }
  result = Arango::Requests::Collection::Shards.execute(server: server, args: args, params: params)
end

#size ⇒ Integer Also known as: count, length

Counts the documents in a collection

Returns:



170
171
172
173
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 170

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:



179
180
181
182
183
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 179

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

#status ⇒ Symbol

The status of the collection as symbol, one of:

  • :unknown

  • :new_born

  • :unloaded

  • :loaded

  • :being_unloaded

  • :deleted

  • :loading

Returns:



86
87
88
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 86

def status
  STATES[@status]
end

#truncate ⇒ Arango::DocumentCollection

Truncates a collection.

Returns:

  • self



162
163
164
165
166
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 162

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:



96
97
98
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 96

def type
  TYPES[@type]
end

#unload_from_memory ⇒ Arango::DocumentCollection

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

Returns:

  • self



226
227
228
229
230
231
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 226

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 



105
106
107
108
 
# File 'lib/arango/edge_collection/instance_methods.rb', line 105

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