Class: V

Inherits:
ActiveOrient::Model show all
Defined in:
lib/model/vertex.rb

Constant Summary

Constants included from OrientDB

OrientDB::DocumentDatabase, OrientDB::DocumentDatabasePool, OrientDB::DocumentDatabasePooled, OrientDB::GraphDatabase, OrientDB::IndexType, OrientDB::OClassImpl, OrientDB::OTraverse, OrientDB::PropertyImpl, OrientDB::RemoteStorage, OrientDB::SQLCommand, OrientDB::SQLSynchQuery, OrientDB::Schema, OrientDB::SchemaProxy, OrientDB::SchemaType, OrientDB::ServerAdmin, OrientDB::User, OrientDB::UsingJava

Instance Attribute Summary

Attributes inherited from ActiveOrient::Model

#metadata

Attributes inherited from ActiveOrient::Base

#metadata

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from ActiveOrient::Model

_to_partial_path, autoload_object, delete_class, #document, #persisted?, #to_ary, to_or, use_or_allocate

Methods included from CustomClass

#like

Methods included from ModelClass

#add_edge_link, #all, #alter_property, #classname, #count, #create, #create_class, #create_index, #create_properties, #create_property, #delete_property, #delete_record, #delete_records, #first, #get, #get_records, #indexes, #last, #link_list, #migrate_property, #namespace_prefix, #naming_convention, #orientdb_class, #print_properties, #properties, #query, #query_database, #require_model_file, #update, #update!, #upsert, #where

Methods included from OrientSupport::Support

#as, #compose_where, #generate_sql_list, #where, #while_s

Methods included from ModelRecord

classname, #delete, #find, #from_orient, #has_property?, #is_edge?, #method_missing, #properties, #query, #reload!, #rid, #rrid, #save, #to_or, #to_s, #transfer_content, #update, #update_attribute, #update_attributes, #version

Methods included from ActiveOrient::BaseProperties

#==, #content_attributes, #default_attributes, #embedded, #set_attribute_defaults, #update_missing

Methods inherited from ActiveOrient::Base

#[], #[]=, attr_accessible, attr_protected, #attributes, #attributes=, belongs_to, display_rid, exclude_the_following_properties, get_rid, has_many, has_one, #included_links, #initialize, #my_metadata, remove_rid, reset_rid_store, serialize, store_rid, #to_model, #update_attribute

Methods included from Conversions

#to_key, #to_param, #to_partial_path

Constructor Details

This class inherits a constructor from ActiveOrient::Base

Dynamic Method Handling

This class handles dynamic methods through the method_missing method in the class ModelRecord

Class Method Details

.create(set: {}, **attributes) ⇒ Object

specialized creation of vertices, overloads model#create

Vertex.create set: { a: 1, b: "2", c: :r }

or

Vertex.create  a: 1, b: "2", c: :r

If a record cannot be created, because an index inhibits it, the original record is silently loaded instead. To avoid this behavior, call create_record and specify »silence: false«



18
19
20
21
 
# File 'lib/model/vertex.rb', line 18

def self.create set: {},  **attributes
db.create_record self, attributes: set.merge(attributes)
  #  query.kind(:create).set( set.merge(attributes) ).execute(reduce: true)
end

.delete(where: {}, **args) ⇒ Object

Vertex.delete fires a “delete vertex” command to the database.

To remove all records of a class, use »all: true« as argument

The rid-cache is reset, too



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/model/vertex.rb', line 30

def self.delete where: {} , **args
if args[:all] == true 
  where = {}
else
  where.merge!(args) if where.is_a?(Hash)
  return 0 if where.empty?
end
# query returns [{count => n }]
count= db.execute { "delete vertex #{ref_name} #{db.compose_where(where)}" }.first[:count] rescue 0
  reset_rid_store
count #  return count of affected records
end

.match(**args) ⇒ Object

Creates a new Match-Statement



47
48
49
 
# File 'lib/model/vertex.rb', line 47

def self.match  **args
  OrientSupport::MatchStatement.new self,  **args
end

.where(*attributes) ⇒ Object 



64
65
66
 
# File 'lib/model/vertex.rb', line 64

def self.where *attributes 
    query_database( match(where: attributes).compile ) { | record | record[classname.pluralize.to_sym] }
end

Instance Method Details

#assign(vertex:, via: E, attributes: {}) ⇒ Object

Assigns another Vertex via an EdgeClass. If specified, puts attributes on the edge.

Wrapper for

Edge.create in: self, out: a_vertex, attributes: { some_attributes on the edge }

returns the assigned vertex, thus enabling to chain vertices through

Vertex.assign() via: E , vertex: VertexClass.create()).assign( via: E, ... )

or (1..100).each{|n| vertex = vertex.assign(via: E2, vertex: V2.create(item: n))}



154
155
156
157
158
159
 
# File 'lib/model/vertex.rb', line 154

def assign vertex: , via: E , attributes: {}

  via.create from: self, to: vertex, set: attributes
  
vertex
end

#detect_edges(kind = :in, edge_name = nil, expand: true) ⇒ Object

v.to_human

> “<V2: in: E2=>1, node : 4>”

v.detect_edges( :in, 2).to_human

> [“<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>”]

v.detect_edges( :in, E1).to_human

> [“<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>”]

v.detect_edges( :in, /e/).to_human

> [“<E2: in : #<V2:0x0000000002e66228>, out : #<V1:0x0000000002ed0060>>”] 

returns a OrientSupport::Array



297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
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
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
 
# File 'lib/model/vertex.rb', line 297

def detect_edges kind = :in,  edge_name = nil, expand: true  #:nodoc:
  ## returns a list of inherent DD classes
  get_superclass = ->(e) do
    if [nil,"", "e", "E", E, :e, :E ].include?(e)
      "E"
    else
      n = orientdb.get_db_superclass(e)
      n =='E' ? e : e + ',' + get_superclass[n]
    end
  end

  expression = case kind
               when :in
                 /^in_/ 
               when :out
                 /^out_/
               else
                 /^in_|^out_/ 
               end

  extract_database_class = ->(c){ y =  c.to_s.gsub(expression, ''); y.empty? ? "E": y   }
  result, the_edges  = []   #  we have to declare result prior to its usage in the loop to make
                            #  its content robust 
  attempt =  0
  loop do
    # get a set of available edge-names 
    # in_{abc} and out_{abc}
    # with "out_" and "in_" as placeholder for E itself
    # populate result in case no further action is required
    result = the_edges = attributes.keys.find_all{ |x|  x =~  expression }
    # eager reloading
    if result.empty? && attempt.zero?
      reload!
      attempt = 1
    else
      break
    end
  end

  if edge_name.present?
    # if a class is provided, match for the ref_name only
    if edge_name.is_a?(Class) 
      result = [ the_edges.detect{ |x| edge_name.ref_name == extract_database_class[x] } ]
    else
      e_name = if edge_name.is_a?(Regexp)
                 edge_name
               else
                 Regexp.new  case  edge_name
                                     #         when  Class
                                     #           edge_name.ref_name 
                                   when String
                                     edge_name
                                   when Symbol
                                     edge_name.to_s 
                                   when Numeric
                                     edge_name.to_i.to_s
                                   end
              end  
      result = the_edges.find_all do |x|
        get_superclass[extract_database_class[x] ].split(',').detect{|x| x =~ e_name } 
      end
    end
  end
  # if expand = false , return the orientdb database name of the edges
  #  this is used by  Vertex#nodes 
  #  it avoids communications with the database prior to submitting the nodes-query
  # if expand = true (default) load the edges instead
  if expand
    OrientSupport::Array.new work_on: self, 
      work_with:   result.compact.map{|x| attributes[x]}.map(&:expand).orient_flatten
  else
    result.map{|x|  extract_database_class[x] }
  end
end

#edges(*args) ⇒ Object

List edges

  1. call without any parameter: list all edges present

  2. call with :in or :out : list any incoming or outgoing edges

  3. call with /regexp/, Class, symbol or string: restrict to this edges, including inheritence If a pattern, symbol string or class is provided, the default is to list outgoing edges

:call-seq:
edges in_or_out, pattern



79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/model/vertex.rb', line 79

def edges *args
  if args.empty?
    detect_edges  :both
  else
    kind =   [:in, :out, :both, :all].detect{|x|  args.include? x }
    if kind.present?
      args =  args - [ kind ]
    else
      kind = :both
    end
    detect_edges  kind, args.first

  end
end

#in_e(edge_name = nil) ⇒ Object Also known as: in

»in« and »out« provide the main access to edges.

»in» is a reserved keyword. Therefor its only an alias to ‘in_e`.

If called without a parameter, all connected edges are retrieved.

If called with a string, symbol or class, the edge-class is resolved and even inherent edges are retrieved.



182
183
184
 
# File 'lib/model/vertex.rb', line 182

def in_e edge_name= nil
  detect_edges :in, edge_name
end

#in_edges ⇒ Object

Retrieves connected edges

The basic usage is to fetch all/ incoming/ outgoing edges

Model-Instance.edges :in  :out | :both, :all

One can filter specific edges by providing parts of the edge-name

Model-Instance.edges /sector/, :in
Model-Instance.edges :out, /sector/
Model-Instance.edges  /sector/
Model-Instance.edges  :in

The method returns an array of expands edges.

»in_edges« and »out_edges« are shortcuts to »edges :in« and »edges :out«

Its easy to expand the result:

tg.out( :ohlc).out.out_edges
 => [["#102:11032", "#121:0"]] 
 tg.out( :ohlc).out.out_edges.from_orient
 => [[#<TG::GRID_OF:0x00000002620e38

this displays the out-edges correctly

whereas tg.out( :ohlc).out.edges( :out)

=> [["#101:11032", "#102:11032", "#94:10653", "#121:0"]]

returns all edges. The parameter (:out) is not recognized, because out is already a nested array.

this

tg.out( :ohlc).first.out.edges( :out)

is a workaround, but using in_- and out_edges is more elegant.



229
230
231
 
# File 'lib/model/vertex.rb', line 229

def in_edges
  edges :in
end

#nodes(in_or_out = :out, via: nil, where: nil, expand: false) ⇒ Object

The Edge-classes can be specified via Classname or a regular expression.

If a regular expression is used, the database-names are searched and inheritance is supported.



101
102
103
104
105
106
107
108
 
# File 'lib/model/vertex.rb', line 101

def nodes in_or_out = :out, via:  nil, where: nil, expand:  false
    edges =  detect_edges( in_or_out, via, expand: false )
    return [] if edges.empty?
    q = query     # q.to_s  => "select from #0x:0x "
    edges = nil if via.nil?
    q.nodes in_or_out, via:  edges , where: where, expand: expand
    detected_nodes= q.execute{| record | record.is_a?(Hash)?  record.values.first : record  }
end

#out(edge_name = nil) ⇒ Object 



188
189
190
 
# File 'lib/model/vertex.rb', line 188

def out edge_name =  nil
  detect_edges :out, edge_name
end

#out_edges ⇒ Object 



232
233
234
 
# File 'lib/model/vertex.rb', line 232

def out_edges
  edges :out
end

#to_human ⇒ Object

Human readable representation of Vertices

Format: < Classname: Edges, Attributes >



244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
 
# File 'lib/model/vertex.rb', line 244

def to_human
  count_and_display_classes = ->(array){array.map(&:class)&.group_by(&:itself)&.transform_values(&:count)} 

  the_ins =    count_and_display_classes[ in_e] 
  the_outs =  count_and_display_classes[ out]

  in_and_out = in_edges.empty? ? "" : "in: #{the_ins}, " 
  in_and_out += out_edges.empty? ? "" : "out: #{the_outs}, " 


  #Default presentation of ActiveOrient::Model-Objects

  "<#{self.class.to_s.demodulize}[#{rid}]: " + in_and_out  + content_attributes.map do |attr, value|
    v= case value
       when ActiveOrient::Model
         "< #{self.class.to_s.demodulize}: #{value.rid} >"
       when OrientSupport::Array
         value.to_s
#          value.rrid #.to_human #.map(&:to_human).join("::")
       else
         value.from_orient
       end
    "%s : %s" % [ attr, v]  unless v.nil?
  end.compact.sort.join(', ') + ">".gsub('"' , ' ')
end

#traverse(in_or_out = :out, via: nil, depth: 1, execute: true, start_at: 0, where: nil) ⇒ Object

Returns a collection of all vertices passed during the traversal

Includes the start_vertex (start_at =0 by default)

If the vector should not include the start_vertex, call with ‘start_at:1` and increase the depth by 1

fires a query

select  from  ( traverse  outE('}#{via}').in  from #{vertex}  while $depth < #{depth}   ) 
        where $depth >= #{start_at}

If » excecute: false « is specified, the traverse-statement is returned (as Orient-Query object)



123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/model/vertex.rb', line 123

def traverse in_or_out = :out, via: nil,  depth: 1, execute: true, start_at: 0, where: nil

  edges = detect_edges( in_or_out, via, expand: false)
  the_query = query kind: 'traverse' 
  the_query.where where if where.present?
  the_query.while "$depth < #{depth} " unless depth <=0
  edges.each{ |ec| the_query.nodes in_or_out, via: ec, expand: false }
  outer_query = OrientSupport::OrientQuery.new from: the_query, where: "$depth >= #{start_at}"
  if execute 
     outer_query.execute
    else
#     the_query.from self  #  complete the query by assigning self 
      the_query            #  returns the OrientQuery  -traverse object
    end
end