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:

  • (String) 


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:

  • (Boolean) 


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:

  • (String) 


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:

  • (String) 


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:

  • 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.



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:



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:

  • (NilClass) 


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:

  • (Boolean) 


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:

  • name (String) —

    The name of the collection.

  • type (Symbol) (defaults to: :edge)
  • database (Arango::Database) (defaults to: Arango.current_database)
  • status (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:



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:



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:



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:



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:

  • (String) 


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:



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:



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:

  • 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) 


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:

  • (Integer) 


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:

  • (Hash) 


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:

  • (Symbol) 


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:



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:

  • (Symbol) 


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:



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