active-orient 0.4 → 0.80

data/lib/model/the_record.rb

@@ -0,0 +1,313 @@
+module ModelRecord
+  ############### RECORD FUNCTIONS ###############
+ 
+	def to_s
+		to_human
+	end
+  ############# GET #############
+
+  def from_orient # :nodoc:
+    self
+  end
+
+  # Returns just the name of the Class
+
+  def self.classname  # :nodoc:
+    self.class.to_s.split(':')[-1]
+  end
+=begin
+flag whether a property exists on the Record-level
+=end
+  def has_property? property
+    attributes.keys.include? property.to_sym
+  end
+
+	def properties 
+		{ "@type" => "d", "@class" => self.metadata[:class] }.merge attributes
+	end
+
+  #
+  # Obtain the RID of the Record  (format: *00:00*)
+  #
+
+  def rid
+    begin
+      "#{@metadata[:cluster]}:#{@metadata[:record]}"
+    rescue
+      "0:0"
+    end
+  end
+=begin
+The extended representation of RID (format: *#00:00* )
+=end
+  def rrid
+    "#" + rid
+  end
+  alias to_orient rrid
+
+  def to_or
+    rid.rid? ?  rrid : "{ #{embedded} }"
+  end
+	
+# returns a OrientSupport::OrientQuery 
+	def query **args
+		OrientSupport::OrientQuery.new( **{ from: self}.merge(args))
+	end
+=begin
+Execute a Query using the current model-record  as origin.
+
+It sends the OrientSupport::OrientQuery to the database and returns an 
+ActiveOrient::Model-Object or an Array of Model-Objects as result. 
+
+*Usage:* Query the Database by traversing through links, edges and vertices starting at a known location
+
+=end
+
+#  def execute query, delete_cash: false
+#    
+#    query.from  rrid if query.is_a?( OrientSupport::OrientQuery) && query.from.nil?
+#		ActiveOrient::Base.remove_rid( self ) if delete_cash
+#    result = orientdb.execute{ query.to_s }
+#		result = if block_given?
+#							 result.is_a?(Array)? result.map{|x| yield x } : yield(result)
+#						 else
+#							 result
+#						 end
+#    if result.is_a? Array  
+#      OrientSupport::Array.new work_on: self, work_with: result.orient_flatten
+#    else
+#      result
+#    end  # return value
+#   end
+#
+=begin
+Fires a »where-Query» to the database starting with the current model-record.
+
+Attributes:
+* a string ( obj.find "in().out().some_attribute >3" )
+* a hash   ( obj.find 'some_embedded_obj.name' => 'test' )
+* an array 
+
+Returns the result-set, ie. a Query-Object which contains links to the addressed records.
+
+=end
+  def find attributes =  {}
+    q = OrientSupport::OrientQuery.new from: self, where: attributes
+    query q
+  end
+ 
+  # Get the version of the object
+  def version  # :nodoc:
+    if document.present?
+      document.version
+    else
+      @metadata[:version]
+    end
+  end
+private
+  def version= version  # :nodoc:
+    @metadata[:version] = version
+  end
+
+  def increment_version # :nodoc: 
+    @metadata[:version] += 1
+  end
+
+public
+
+  ############# DELETE ###########
+
+# Removes the Model-Instance from the database.
+#
+# It is overloaded in Vertex and Edge.
+
+def delete 
+  orientdb.delete_record  self 
+end
+
+
+########### UPDATE ############
+
+=begin
+Convenient update of the dataset 
+
+A) Using PATCH
+
+Previously changed attributes are saved to the database.
+
+Using the optional »:set:« argument ad-hoc attributes can be defined
+    V.create_class :contracts
+    obj = Contracts.first
+    obj.name =  'new_name'
+    obj.update set: { yesterdays_event: 35 }
+updates both, the »name« and the »yesterdays_event«-properties
+
+B) Manual Modus
+
+Update accepts a Block. The contents are parsed to »set«. Manual conversion of ruby-objects
+to the database-input format is necessary
+
+i.e.
+	 hct is an Array of ActiveOrient::Model-records. 
+then
+	 obj.update {  "positions =  #{hct.to_or} " }
+translates to
+	 update #83:64 set positions =  [#90:18, #91:18, #92:18]   return after @this
+and returns the modified record.
+
+The manual modus accepts the keyword »remove«. 
+
+	 obj.update(remove: true) {  "positions =  #{hct.first.to_or} " }
+translates to
+	 update #83:64  remove  positions =  #90:18   return after @this
+
+This can be achieved by
+   obj.positions
+
+
+If the update process is not successful, nil is returned
+=end
+
+def update set: {}, remove: {}, **args
+	logger.progname = 'ActiveOrient::Model#Update'
+	#	query( kind: update,  )
+	if block_given?			# calling vs. a block is used internally
+		# to remove an Item from lists and sets call update(remove: true){ query }
+		set_or_remove =  args[:remove].present? ? "remove" : "set"
+		#transfer_content from: 	 
+		updated_record = 	db.execute{  "update #{rrid}  #{ yield }  return after $current" } &.first
+		transfer_content from: updated_record  if updated_record.present?
+	else
+		set = if remove.present?
+						{ remove: remove.merge!( args) }
+					elsif set.present?
+						 set.merge!( args) 
+					else
+						 args 
+					end
+		#	set.merge updated_at: DateTime.now
+		if rid.rid?
+			q= query.kind(:update)
+			if remove.present?
+				q.remove(remove)
+			else
+				q.set(set)
+			end
+		transfer_content from: 	q.execute(reduce: true){ |y| y[:$current].reload! }
+		else  # new record
+			 self.attributes.merge!  set
+			 save
+		end
+	end
+end
+
+# mocking active record  
+  def update_attribute the_attribute, the_value # :nodoc:
+    update the_attribute => the_value.to_or
+  end
+
+  def update_attributes **args    # :nodoc:
+    update  args
+  end
+
+  ########## SAVE   ############
+ 
+=begin
+Saves the record  by calling update  or  creating the record
+
+  ORD.create_class :a
+  a =  A.new
+  a.test = 'test'
+  a.save
+
+  a =  A.first
+  a.test = 'test'
+  a.save
+
+=end
+	def save
+		transfer_content from:  if rid.rid?
+															db.update self, attributes, version
+														else
+															db.create_record  self, attributes: attributes, cache: false 
+														end
+		ActiveOrient::Base.store_rid self
+	end
+
+  def reload! 
+    transfer_content from: db.get_record(rid) 
+		self
+  end
+
+
+  ########## CHECK PROPERTY ########
+
+=begin
+  An Edge is defined
+  * when inherent from the superclass »E» (formal definition)
+  * if it has an in- and an out property
+
+  Actually we just check the second term as we trust the constructor to work properly
+=end
+
+  def is_edge? # :nodoc:
+    attributes.keys.include?('in') && attributes.keys.include?('out')
+  end
+
+=begin
+How to handle other calls
+
+* if  attribute is specified, display it
+* if  attribute= is provided, assign to the known property or create a new one
+
+Example:
+  ORD.create_class :a
+  a = A.new
+  a.test= 'test'  # <--- attribute: 'test=', argument: 'test'
+  a.test	  # <--- attribute: 'test' --> fetch attributes[:test]
+
+Assignments are performed only in ruby-space.
+
+Automatic database-updates are deactivated for now
+=end
+  def method_missing *args
+    # if the first entry of the parameter-array is a known attribute
+    # proceed with the assignment
+    if args.size == 1
+       attributes[args.first.to_sym]  # return the attribute-value
+    elsif args[0][-1] == "=" 
+      if args.size == 2
+#	if rid.rid? 
+#	  update set:{ args[0][0..-2] => args.last }
+#	else
+	  self.attributes[ args[0][0..-2]  ] = args.last
+#	end
+      else
+	  self.attributes[ args[0][0..-2]  ] = args[1 .. -1]
+#	update set: {args[0][0..-2] => args[1 .. -1] } if rid.rid?
+      end
+    else
+      raise NameError, "Unknown method call #{args.first.to_s}", caller
+    end
+  end
+#end
+
+#protected
+  def transfer_content  from:
+		# »from« can be either 
+		# a model record (in case of  create-record, get_record) or
+		# a hash containing {"@type"=>"d", "@rid"=>"#xx:yy", "@version"=>n, "@class"=>'a_classname'} 
+		# and a list of updated properties (in case of db.update). Then  update the version field and the 
+		# attributes.
+			return nil if from.nil?	
+			if from.is_a? ActiveOrient::Model
+       @metadata = from.metadata
+       self.attributes =  from.attributes
+			else
+				self.version =  from['@version']
+				# throw away from["@..."] and convert keys to symbols, finally merge to attributes
+				@attributes.merge! Hash[ from.delete_if{|k,_| k =~ /^@/}.map{|k,v| [k.to_sym, v.from_orient]}]
+			end
+			self  # return the modified object
+  end
+end

data/lib/model/vertex.rb

@@ -0,0 +1,371 @@
+class V   < ActiveOrient::Model
+  ## link to the library-class
+ 
+=begin
+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«
+
+=end
+	def self.create set: {},  **attributes
+		db.create_record self, attributes: set.merge(attributes)
+	#	query.kind(:create).set( set.merge(attributes) ).execute(reduce: true)
+  end
+=begin
+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
+=end
+  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
+
+
+=begin
+Creates a new Match-Statement
+=end
+	def self.match  **args
+		OrientSupport::MatchStatement.new self,  **args
+	end
+
+=begin
+Performs a Where-Query on the vertex-class
+
+The where-cause narrows the sample to certain records. 
+
+They are returned as OrientSupport::Array
+ 
+Internally a match-query is fired. 
+
+To fire a »select from class where« query, use »Class.custom_where«.
+=end
+
+
+def self.where *attributes 
+    query_database( match(where: attributes).compile ) { | record | record[classname.pluralize.to_sym] }
+end
+
+=begin
+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 
+=end
+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
+
+	# Lists all connected Vertices
+  # ( returns a OrientSupport::Array )
+	#
+	# 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.
+	#
+	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
+
+
+	# 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)
+	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
+
+	
+
+=begin
+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))}
+=end
+
+  def assign vertex: , via: E , attributes: {}
+
+    via.create from: self, to: vertex, set: attributes
+    
+		vertex
+  end
+
+## Optimisation (not implemented jet)
+	#
+	#         "LET $a = CREATE VERTEX VTest SET name = 'John';" +
+	#                      "CREATE EDGE ETest FROM :ParentRID TO $a;" +
+	#                      "RETURN $a;", params)
+
+
+
+
+=begin
+»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.
+
+=end
+
+  def in_e edge_name= nil
+    detect_edges :in, edge_name
+  end
+	
+	alias_method :in, :in_e
+
+  def out edge_name =  nil
+    detect_edges :out, edge_name
+  end
+=begin
+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.
+=end
+  def in_edges
+    edges :in
+  end
+  def out_edges
+    edges :out
+  end
+
+ # def remove
+ #   db.delete_vertex self
+#	end
+=begin
+Human readable representation of Vertices
+
+Format: < Classname: Edges, Attributes >
+=end
+	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
+
+
+
+
+
+#protected
+#Present Classes (Hierarchy) 
+#---
+#- - E
+#  - - - e1
+#      - - e2
+#        - e3
+#- - V
+#  - - - v1
+#      - - v2
+
+# v.to_human
+# => "<V2[#36:0]: 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
+	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
+end