arcadedb 0.3.1 → 0.4

data/lib/match.rb

@@ -0,0 +1,216 @@
+#require 'active_support/inflector'
+
+module Arcade
+	######################## MatchConnection ###############################
+
+	MatchAttributes = Struct.new(:edge, :direction, :as, :count, :where, :while, :max_depth , :depth_alias, :path_alias, :optional )
+
+	# where and while can be composed incremental
+	# direction, as, connect and edge cannot be changed after initialisation
+  class MatchConnection
+    include Support::Sql
+
+    def initialize edge= nil, direction: :both, as: nil, count: 1, **args
+
+      the_edge = edge.is_a?( Class ) ?  edge.ref_name : edge.to_s   unless edge.nil? || edge == E
+			@q =  MatchAttributes.new  the_edge ,  # class
+								direction, #		  may be :both, :in, :out
+								as,				 #      a string
+								count,     #      a number 
+								args[:where],
+								args[:while],
+								args[:max_depth],
+								args[:depth_alias],      # not implemented
+								args[:path_alias],       # not implemented
+								args[:optional]          # not implemented
+    end
+
+    def direction= dir
+      @q[:direction] =  dir
+    end
+
+
+		def direction
+			fillup =  @q[:edge].present? ? @q[:edge] : ''
+			case @q[:direction]
+			when :both
+				".both(#{fillup})"
+			when :in
+				".in(#{fillup})"
+			when :out
+				".out(#{fillup})"
+      when :both_vertex, :bothV
+				".bothV()"
+			when :out_vertex, :outV
+				".outV()"
+			when :in_vertex, :inV
+				".inV()"
+     when :both_edge, :bothE
+			 ".bothE(#{fillup})"
+			when :out_edge, :outE
+				".outE(#{fillup})"
+			when :in_edge, :outE
+				".inE(#{fillup})"
+			end
+
+		end
+
+		def count c=nil
+			if c
+				@q[:count] = c
+			else
+				@q[:count]
+			end
+		end
+
+		def max_depth d=nil
+			if d.nil?
+				@q[:max_depth].present? ? "maxDepth: #{@q[:max_depth] }" : nil
+			else
+				@q[:max_depth] = d
+			end
+		end
+		def edge
+			@q[:edge]
+		end
+
+		def compose
+				where_statement =( where.nil? || where.size <5 ) ? nil : "where: ( #{ generate_sql_list( @q[:where] ) })"
+				while_statement =( while_s.nil? || while_s.size <5) ? nil : "while: ( #{ generate_sql_list( @q[:while] )})"
+
+				ministatement = "{"+ [ as, where_statement, while_statement, max_depth].compact.join(', ') + "}"
+				ministatement = "" if ministatement=="{}"
+
+     (1 .. count).map{|x| direction }.join("") + ministatement
+
+    end
+		alias :to_s :compose
+
+  end  # class
+
+
+	######################## MatchStatement ################################
+
+	MatchSAttributes = Struct.new(:match_class, :as, :where )
+  class MatchStatement
+    include Support
+    def initialize match_class, as: 0,  **args
+			reduce_class = ->(c){ c.is_a?(Class) ? c.ref_name : c.to_s }
+
+			@q =  MatchSAttributes.new( reduce_class[match_class],  # class
+								as.respond_to?(:zero?) && as.zero? ?  reduce_class[match_class].pluralize : as	,
+								args[ :where ])
+
+			@query_stack = [ self ]
+		end
+
+		def match_alias
+			"as: #{@q[:as]}"
+		end
+
+
+
+		# used for the first compose-statement of a compose-query
+		def compose_simple
+				where_statement = where.is_a?(String) && where.size <3 ?  nil :  "where: ( #{ generate_sql_list( @q[:where] ) })"
+			'{'+ [ "class: #{@q[:match_class]}",  as , where_statement].compact.join(', ') + '}'
+		end
+
+
+		def << connection
+			@query_stack << connection
+			self  # return MatchStatement
+		end
+		#
+		def compile &b
+     "match " + @query_stack.map( &:to_s ).join + return_statement( &b )
+		end
+
+
+		# executes the standard-case.
+		# returns
+		#  * as: :hash   : an array of  hashes
+		#  * as: :array  : an array of hash-values
+		#  * as  :flatten: a simple array of hash-values
+		#
+		# The optional block is used to customize the output.
+		# All previously defiend »as«-Statements are provided though the control variable.
+		#
+		# Background
+		# A match query   "Match {class aaa, as: 'aa'} return aa "
+		#
+		# returns [ aa: { result of the query, a Vertex or a value-item  }, aa: {}...}, ...] ]
+		# (The standard case)
+		#
+		# A match query   "Match {class aaa, as: 'aa'} return aa.name "
+		# returns [ aa.name: { name  }, aa.name: { name }., ...] ]
+		#
+		# Now, execute( as: :flatten){ "aa.name" }  returns
+		#  [name1, name2 ,. ...]
+		#
+		#
+		# Return statements  (examples from https://orientdb.org/docs/3.0.x/sql/SQL-Match.html)
+		#  "person.name as name, friendship.since as since, friend.name as friend"
+		#
+		#  " person.name + \" is a friend of \" + friend.name as friends"
+		#
+		#  "$matches"
+		#  "$elements"
+		#  "$paths"
+		#  "$pathElements"
+		#
+		#
+		def execute as: :hash, &b
+			r = V.db.execute{ compile &b }
+			case as
+			when :hash
+				r
+			when :array
+			 r.map{|y| y.values}
+			when :flatten
+			 r.map{|y| y.values}.orient_flatten
+			else
+				raise ArgumentError, "Specify parameter «as:» with :hash, :array, :flatten"
+		 end
+		end
+#		def compose
+#
+#			'{'+ [ "class: #{@q[:match_class]}",
+#					"as: #{@as}" , where, while_s,
+#						@maxdepth >0 ? "maxdepth: #{maxdepth}": nil  ].compact.join(', ')+'}'
+#		end
+
+		alias :to_s :compose_simple
+
+
+##  return_statement
+		#
+		# summarizes defined as-statements ready to be included as last parameter
+		# in the match-statement-stack
+		#
+		# They can be modified through a block.
+		#
+		# i.e
+		#
+		# t= TestQuery.match(  where: {a: 9, b: 's'}, as: nil ) << E.connect("<-", as: :test)
+		# t.return_statement{|y| "#{y.last}.name"}
+		#
+		# =>> " return  test.name"
+		#
+		#return_statement is always called through compile
+		#
+		# t.compile{|y| "#{y.last}.name"}
+
+    private
+		def return_statement
+			resolve_as = ->{ @query_stack.map{|s| s.as.split(':').last unless s.as.nil? }.compact }
+			" return " + statement = if block_given?
+										a= yield resolve_as[]
+										a.is_a?(Array) ? a.join(', ') :  a
+									else
+										resolve_as[].join(', ')
+									end
+		end
+	end  # class
+
+end # module

data/lib/model/basicdocument.rb

@@ -0,0 +1,7 @@
+module Arcade
+  class Basicdocument  <   Document
+   # schema schema.strict    #  -- throws an error if  specified keys are missing
+    attribute :values?, Types::Hash
+
+  end
+end

data/lib/model/basicedge.rb

@@ -0,0 +1,6 @@
+module Arcade
+  class Basicedge  <   Edge
+   # schema schema.strict    #  -- throws an error if  specified keys are missing
+    attribute :values?, Types::Hash
+  end
+end

data/lib/model/basicvertex.rb

@@ -0,0 +1,6 @@
+module Arcade
+  class Basicvertex  <  Vertex
+   # schema schema.strict    #  -- throws an error if  specified keys are missing
+    attribute :values?, Types::Hash
+  end
+end

data/lib/model/document.rb

@@ -0,0 +1,10 @@
+module Arcade
+  class Document  <  Base
+   # schema schema.strict    #  -- throws an error if  specified keys are missing
+
+    ## has to be overloaded
+   # def accepted_methods
+   #
+   # end
+  end
+end

data/lib/model/edge.rb

@@ -0,0 +1,47 @@
+module Arcade
+  class Edge  <  Base
+   # schema schema.strict    #  -- throws an error if  specified keys are missing
+    attribute :in, Types::Rid
+    attribute :out, Types::Rid
+
+    def accepted_methods
+      super + [ :vertices, :in, :out, :inV, :outV ]
+    end
+    #
+    # Add Contrains to the edge
+    # CREATE INDEX Watched_out_in ON <edge type«  (`@out`, `@in`) UNIQUE
+    #
+    def self.create  from:, to:, **attr
+        db.create_edge  database_name, from: from, to: to, **attr
+    end
+
+    def delete
+      db.execute{  "delete edge #{ rid }" }.select_result
+    end
+    ## gets the adjacent Vertex
+    def inV
+      query( projection: "inV()").query.select_result
+    end
+    def outV
+      query( projection: "outV()").query.select_result
+    end
+    def vertices in_or_out = nil
+  case in_or_out
+      when :in
+        inV
+      when :out
+        outV
+      else
+        [inV, outV]
+      end
+    end
+
+    alias bothV vertices
+
+
+    def to_human
+      "<#{self.class.to_s.snake_case}[#{rid}] :.: #{ out }->#{invariant_attributes}->#{ attributes[:in] }>"
+    end
+
+  end
+end

data/lib/model/vertex.rb

@@ -0,0 +1,238 @@
+module Arcade
+  class Vertex  < Base
+
+#    include Arcade::Support::Sql
+    include Arcade::Support::Model   #  instance methods
+    extend Arcade::Support::Model    #  class methods
+
+    attribute :in?, Types::Nominal::Any
+    attribute :out?, Types::Nominal::Any
+    #                                                                                               #
+    def accepted_methods
+     super + [ :in, :out, :both, :edges, :inE, :outE, :bothE,  :assign]
+    end
+    ## ----------------------------------------- Class Methods------------------------------------ ##
+    #                                                                                               #
+=begin
+    Vertex.delete fires a "delete vertex" command to the database.
+
+    To remove all records  use  »all: true« as argument
+
+    To remove a specific rid, use  rid: "#nn:mmm" as argument
+
+    "where" parameter is optional
+
+     ExtraNode.delete where: { item: 67  }  == ExtraNode.delete item: 67
+
+=end
+    def self.delete where: {} , **args
+      if args[:all] == true
+        where = {}
+      elsif args[:rid].present?
+        return db.execute { "delete vertex #{args[:rid]}" }.first["count"]
+      else
+        where.merge!(args) if where.is_a?(Hash)
+        return 0 if where.empty?
+      end
+      # query returns [{count => n }]
+      db.execute { "delete vertex #{database_name} #{compose_where(where)}"  } &.first[:count] rescue 0
+    end
+
+=begin
+   Creates a Vertex-Instance.
+   Similar to `Vertex#insert`.
+
+   Difference is the presence of a `created` property, a timestamp set to the time and date of creation.
+=end
+
+    def self.create timestamp: true, **args
+      #t= timestamp ?  ", created = Date(#{DateTime.now.to_i}) "  : ""
+      t= timestamp ?  ", created = sysdate() "  : ""
+      db.execute { "create VERTEX #{database_name} set #{args.map{|x,y| [x,y.to_or].join("=")}.join(', ')+t}" } &.first.allocate_model(false)
+    end
+
+
+## get adjacent nodes based on a query on the actual model
+
+
+    def self.nodes in_or_out = :both, via: nil ,  **args
+
+      s =  Query.new from: self
+      s.nodes in_or_out, via: via, **args
+      s.query &.select_result
+    end
+
+
+    #                                                                                               #
+    ## ---------------------------------   Instance    Methods   --------------------------------- ##
+    #
+    #  We need expand as fallback if a vertex, which is stored as link, is automatically loaded
+    #
+      def expand
+        self
+      end
+    # Supports where:  -->  Strategie.first nodes  where: {size: 10}
+    # "select  both()[ size = 10  ]  from #113:8 "
+    def nodes in_or_out=:both, depth= 1, via: nil , execute: true, **args
+      s =  Query.new from: rid
+      s.nodes in_or_out, via: via, **args
+      if execute
+         s.query &.select_result
+       else
+         s  #  just return the query
+       end
+    end
+
+    # Supports where: { where condition for edges }
+    def edges in_or_out = :both, depth= 1, via: nil , execute: true, **args
+      in_or_out = in_or_out.to_s + "E"
+      nodes in_or_out, depth, via: via , execute: execute, **args
+    end
+
+
+    # get Vertices through in by edges of type via
+    def in count=0, via:nil
+      if count.zero?
+        @bufferedin ||= nodes :in,  1, via: via
+      else
+        nodes :in, count, via: via   # not cached
+      end
+    end
+
+    # get Vertices through out by edges of type via
+    def out count=0, via:nil
+      if count.zero?
+        @bufferedout ||= nodes :out, 1,  via: via
+      else
+        nodes :out, count, via: via   # not cached
+      end
+    end
+    #
+    # get all Vertices connected by edges of type via
+    def both count=0, via:nil
+      if count.zero?
+        @bufferedboth ||= nodes :both, 1, via: via
+      else
+        nodes :both, count, via: via   # not cached
+      end
+    end
+
+
+    # get via-type-edges  through in
+    def inE count=1, via:nil
+      nodes :inE,  count, via: via
+    end
+    #
+    # get via-type-edges  through  out
+    def outE count=1, via:nil
+      nodes :outE, count,  via: via
+    end
+
+    # get  all via-type-edges
+    def bothE  count=1, via:nil
+      nodes :bothE, count, via: via
+    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 » execute: false « is specified, the traverse-statement is returned (as Arcade::Query object)
+  #
+  # Multiple Edges can be specifies in the via-parameter (use Array-notation)
+    # e.i.
+    #  traverse( :in, via: [TG::DateOf, Arcade::HasOrder], depth: 4, start_at: 1 ).map(&:w).reverse
+    #
+	def traverse in_or_out = :out, via: nil,  depth: 1, execute: true, start_at: 0, where: nil
+
+			the_query = query kind: 'traverse'
+      the_query.projection  in_or_out.to_s + "(" + resolve_edge_name(*via) + ")"
+			the_query.where where if where.present?
+			the_query.while "$depth < #{depth} " unless depth <=0
+			outer_query = Query.new from: the_query, where: "$depth >= #{start_at}"
+			if execute
+        outer_query.execute.allocate_model
+				else
+		#			the_query.from self  #  complete the query by assigning self
+					the_query            #  returns the Query  -traverse object
+				end
+		end
+
+=begin
+Assigns another Vertex via an EdgeClass. If specified, puts attributes on the edge.
+
+Returns the reloaded assigned vertex
+
+Wrapper for
+  Edge.create in: self, out: a_vertex,  some: attributes.  on: the,  edge: type }
+
+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:   , **attributes
+
+    via.create from: self, to: vertex,  **attributes
+
+    db.get vertex.rid  # return the assigned vertex
+  rescue IndexError => e
+    db.logger.error "Edge not created, already present."
+    vertex  #  return the vertex (for chaining)
+  rescue ArgumentError => e
+    db.logger.error "ArgumentError: #{e.message}"
+    nil
+  end
+
+
+  def remove
+    db.execute{ "delete vertex #{rid}" }
+	end
+=begin
+Human readable representation of Vertices
+
+Format: < Classname: Edges, Attributes >
+=end
+	def to_human
+
+    in_and_out = -> { "{#{self.in.count}->}{->#{self.out.count }}, " }
+
+		#Default presentation of Arcade::Base::Model-Objects
+
+		"<#{self.class.to_s.snake_case}[#{rid}]:"  +
+      in_and_out[] +
+      invariant_attributes.map do |attr, value|
+			v= case value
+				 when  Class
+					 "< #{self.class.to_s.snake_case}: #{value.rid} >"
+				 when Array
+					 value.to_s
+				 else
+					 value.from_db
+				 end
+			"%s: %s" % [ attr, v]  unless v.nil?
+		end.compact.sort.join(', ') + ">".gsub('"' , ' ')
+	end
+
+
+    def refresh
+      # force reloading of edges and nodes
+      # edges are not cached (now)
+      @bufferedin, @bufferedout, @bufferedboth = nil
+      super
+    end
+    # expose class method to instances (as private)
+#    private  define_method :resolve_edge_name, &method(:resolve_edge_name)
+#    private_class_method  :resolve_edge_name
+end
+end

data/lib/models.rb

@@ -0,0 +1,6 @@
+require_relative "../lib/model/document.rb"
+require_relative "../lib/model/vertex.rb"
+require_relative "../lib/model/edge.rb"
+require_relative "../lib/model/basicvertex.rb"
+require_relative "../lib/model/basicdocument.rb"
+require_relative "../lib/model/basicedge.rb"