active-orient 0.42 → 0.79

data/lib/model/the_record.rb

@@ -0,0 +1,266 @@
+module ModelRecord
+  ############### RECORD FUNCTIONS ###############
+
+  ############# 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_s
+  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
+=begin
+Query uses the current model-record  as origin of the query.
+
+It sends the OrientSupport::OrientQuery directly to the database and returns an 
+ActiveOrient::Model-Object or an Array of Model-Objects as result. 
+
+*Usage:* Query the Database by traversing through edges and vertices starting at a known location
+
+=end
+
+  def query query
+    
+    query.from = rrid if query.is_a? OrientSupport::OrientQuery
+    result = orientdb.execute do
+      query.to_s
+    end
+    if result.is_a? Array  
+      OrientSupport::Array.new work_on: self, work_with: result
+    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
+
+  def version= version  # :nodoc:
+    @metadata[:version] = version
+  end
+
+  def increment_version # :nodoc: 
+    @metadata[:version] += 1
+  end
+
+
+  ############# DELETE ###########
+
+# Removes the Model-Instance from the database.
+#
+# It is overloaded in Vertex and Edge.
+
+def remove 
+  orientdb.delete_record self
+  ActiveOrient::Base.remove_rid self ##if is_edge? # removes the obj from the rid_store
+end
+
+alias delete remove
+
+########### UPDATE ############
+
+=begin
+Convient update of the dataset by calling sql-patch
+
+Previously changed attributes are saved to the database.
+
+Using the optional :set argument ad-hoc attributes can be defined
+
+    obj = ActiveOrient::Model::Contracts.first
+    obj.name =  'new_name'
+    obj.update set: { yesterdays_event: 35 }
+updates both, the »name« and the »yesterdays_event«-properties
+
+_note:_ The keyword »set« is optional, thus
+    obj.update  yesterdays_event: 35 
+is identical
+=end
+
+  def update set:{}, add: nil, to: nil, **args
+    logger.progname = 'ActiveOrient::Model#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: 	 query( "update #{rrid} #{set_or_remove} #{ yield }  return after @this" )&.first
+		 else
+			set.merge! args
+		#	set.merge updated_at: DateTime.now
+
+			if rid.rid?
+				transfer_content from:  db.update( self, set, version )
+				# if the updated dataset changed, drop the changes made siently
+		#		self # return value
+			else  # new record
+				@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
+
+
+  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.
+			if from.is_a? ActiveOrient::Model
+       @metadata = from.metadata
+       @attributes =  from.attributes
+			else
+				self.version =  from['@version']
+				# throw from["@..."] away and convert keys to symbols, merge that into attributes
+				@attributes.merge! Hash[ from.delete_if{|k,_| k =~ /^@/}.map{|k,v| [k.to_sym, v.from_orient]}]
+			end
+  end
+  ########## CHECK PROPERTY ########
+
+=begin
+  An Edge is defined
+  * when inherented 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 constuctor 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
+
+
+end

data/lib/model/vertex.rb

@@ -0,0 +1,236 @@
+class V   < ActiveOrient::Model
+  ## link to the library-class
+ 
+=begin
+specialized creation of vertices, overloads model#create
+=end
+	def self.create( **keyword_arguments )
+		new_vert = db.create_vertex self, attributes: keyword_arguments
+		new_vert =  new_vert.pop if new_vert.is_a?( Array) && new_vert.size == 1
+		if new_vert.nil?
+			logger.error('Vertex'){ "Table #{ref_name} ->>  create failed:  #{keyword_arguments.inspect}" } 
+		elsif block_given?
+			yield new_vert
+		else
+			new_vert # returns the created vertex (or an array of created vertices)
+		end
+  end
+=begin
+Vertex#delete fires a "delete vertex" command to the database.
+The where statement can be empty ( "" or {}"), then all vertices are removed 
+
+The rid-cache is reseted, too
+=end
+  def self.delete where: ""
+    db.execute { "delete vertex #{ref_name} #{db.compose_where(where)}" }
+    reset_rid_store
+  end
+
+#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>>"] 
+#
+  def detect_edges kind = :in,  edge_name = nil # :nodoc:
+    ## returns a list of inherented classes
+    get_superclass = ->(e) do
+      n = orientdb.get_db_superclass(e)
+      n =='E' ? e : e + ',' + get_superclass[n]
+    end
+		if edge_name.nil?
+      edges(kind).map &:expand
+		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
+	    the_edges = @metadata[:edges][kind].find_all{|y| get_superclass[y].split(',').detect{|x| x =~ e_name } }
+    
+			the_edges.map do | the_edge|
+		  candidate= attributes["#{kind.to_s}_#{the_edge}".to_sym]
+			candidate.present?  ? candidate.map( &:expand ).first  : nil 
+			end
+    end
+  end
+
+	# Lists all connected Vertices
+	#
+	# The Edge-classes can be specified via Classname or a regular expression. 
+	#
+	# If a regular expression is used, the database-names are searched.
+	def nodes in_or_out = :out, via:  nil, where: nil, expand:  false
+		if via.present?
+			edges = detect_edges( in_or_out, via )
+			detected_nodes = edges.map do |e|
+				q = OrientSupport::OrientQuery.new 
+				q.nodes in_or_out, via: e.class, where: where, expand: expand
+				query( q )
+			end.first
+		end
+	end
+
+
+  
+=begin
+»in« and »out« provide the main access to edges.
+»in» is a reserved keyword. Therfore 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 inherented 
+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/ incomming/ outgoing edges
+
+  Model-Instance.edges :in # :out | :all
+
+One can filter specific edges by providing parts of the edge-name
+
+  Model-Instance.edges 'in_sector'
+  Model-Instance.edges /sector/
+
+The method returns an array of rid's.
+
+Example:
+
+  Industry.first.attributes.keys
+   => ["in_sector_classification", "k", "name", "created_at", "updated_at"]  # edge--> in ...
+
+  Industry.first.edges :out
+    => []
+
+  Industry.first.edges :in
+  => ["#61:0", "#61:9", "#61:21", "#61:33", "#61:39", "#61:93", "#61:120", "#61:150", "#61:240", "#61:252", "#61:264", "#61:279", "#61:303", "#61:339" ...]
+  
+
+
+To fetch the associated records use the ActiveOrient::Model.autoload_object method
+  
+  ActiveOrient::Model.autoload_object Industry.first.edges( :in).first	
+  # or
+  Industry.autoload_object Industry.first.edges( /sector/ ).first
+   => #<SectorClassification:0x00000002daad20 @metadata={"type"=>"d", "class"=>"sector_classification", "version"=>1, "fieldTypes"=>"out=x,in=x", "cluster"=>61, "record"=>0},(...)
+
+=end
+  
+  def edges kind=:all  # :all, :in, :out 
+    expression = case kind
+		 when :all
+		   /^in|^out/ 
+		 when :in
+		   /^in/ 
+		 when :out
+		   /^out/ 
+		 when String
+		   /#{kind}/
+		 when Regexp
+		   kind
+		 else
+		   return  []
+		 end
+
+    edges = attributes.keys.find_all{ |x| x =~  expression }
+    edges.map{|x| attributes[x]}.flatten
+  end
+
+=begin
+»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 walkaround, 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 represantation 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
+end