arcadedb 0.4 → 0.5.0

data/lib/{support → arcade/support}/model.rb

@@ -23,34 +23,38 @@ module Arcade
       if response.is_a? Hash
         # save rid to a safe place
         temp_rid = response.delete :"@rid"
-        type           = response.delete :"@type"
-        cat            = response.delete :"@cat"
+        type     = response.delete :"@type"
+        cat      = response.delete :"@cat"
 
         return response if type.nil?
         temp_rid = "#0:0" if temp_rid.nil?
         type = "d" if type.nil?
         # extract type infos  and convert to database-name
-        n, type_name = type.camelcase_and_namespace
-        n = self.namespace if n.nil?
+        namespace, type_name = type.camelcase_and_namespace
+        namespace = self.namespace if namespace.nil?
         # autoconvert rid's in attributes to model-records  (exclude edges!)
         if auto && !(cat.to_s =='e')
           response.transform_values! do  |x|
             case x
             when String
-              x.rid? ?  x.load_rid : x
+              x.rid? ?  x.load_rid : x                   # follow links
             when Array
+              a =[]
               x.map do| y |
-                if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
-                  y.allocate_model(false)
-                elsif y.rid?                             # if links are present, load the object
-                  y.load_rid(false) # do not autoload further records, prevents from recursive locking
-                else
-                  y
-                end
+                # Thread.new do  ## thread or fiber decrease the performance significantly.
+                  if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
+                    y.allocate_model(false)
+                  elsif y.rid?                             # if links are present, load the object
+                    y.load_rid(false) # do not autoload further records, prevents from recursive locking
+                  else
+                    y
+                  end
+               # end
               end
             when Hash
               if x.include?(:@type)
-                x.allocate_model(false)
+                #x.allocate_model(false)
+                _allocate_model(x,false)
               else
                 x.transform_values!{|z|  z.rid? ?  z.load_rid(false) : z }
               end
@@ -60,7 +64,7 @@ module Arcade
           end
         end
         # choose the appropriate class
-        klass=  Dry::Core::ClassBuilder.new(  name: type_name, parent:  nil, namespace:  n).call
+        klass=  Dry::Core::ClassBuilder.new(  name: type_name, parent: nil, namespace: namespace ).call
         #
       begin
         # create a new object of that  class with the appropriate attributes
@@ -74,10 +78,11 @@ module Arcade
      elsif response.is_a? Array
        puts "Allocate_model..detected array"
        ## recursive behavior, just in case
-       response.map{ | y | _allocate_model y }
+       response.map{ | y | _allocate_model y, auto }
      elsif response.rid?
        # Autoload rid's
        response.load_rid
+      # auto ? response.load_rid : response
      else
        response
       end

data/lib/arcade/version.rb

@@ -1,3 +1,3 @@
 module Arcade
-  VERSION = "0.4"
+  VERSION = "0.5.0"
 end

data/lib/arcade.rb

@@ -16,21 +16,21 @@ require 'yaml'
 require 'securerandom'
 require 'httpx'
 require 'arcade/errors'
-require_relative '../lib/support/object'
-require_relative '../lib/support/string'
-require_relative '../lib/support/class'
-require_relative '../lib/support/sql'
-require_relative '../lib/support/model'
-require_relative '../lib/arcade/logging'
-require_relative '../lib/config'
-require_relative '../lib/support/conversions'
+require_relative '../lib/arcade/support/object'
+require_relative '../lib/arcade/support/string'
+require_relative '../lib/arcade/support/class'
+require_relative '../lib/arcade/support/sql'
+require_relative '../lib/arcade/support/model'
+require_relative '../lib/arcade/support/conversions'
 require_relative '../lib/arcade/api/primitives'
 require_relative '../lib/arcade/api/operations'
 require_relative '../lib/arcade/base'
+require_relative '../lib/arcade/logging'
+require_relative '../lib/arcade/config'
 require_relative '../lib/arcade/database'
-require_relative '../lib/init'
+require_relative '../lib/arcade/match'
+require_relative '../lib/arcade/query'
+require_relative '../lib/arcade/init'
 require_relative "../lib/models"
-require_relative '../lib/query'
-require_relative '../lib/match'
 require_relative '../lib/railtie'  if defined? Rails::Railtie
 

data/lib/model/document.rb

@@ -6,5 +6,27 @@ module Arcade
    # def accepted_methods
    #
    # end
+   def self.create **attributes
+     Api.create_document  db.database, database_name, session_id: db.session,  **attributes
+   end
+
+=begin
+    Document.delete fires a "delete vertex" command to the database.
+    To remove all records  use  »all: true« as argument
+
+    The "where" parameter is optional
+=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 }]
+      #  puts "delete from  #{database_name} #{compose_where(where)}"
+      db.transmit { "delete  from `#{database_name}` #{compose_where(where)}"   } &.first[:count] rescue 0
+    end
+
   end
 end

data/lib/model/edge.rb

@@ -13,6 +13,18 @@ module Arcade
     #
     def self.create  from:, to:, **attr
         db.create_edge  database_name, from: from, to: to, **attr
+    rescue Arcade::QueryError => e
+      if  e.message =~ /Duplicated key\s+.+\sfound on index/
+        if e.args.keys.first == :exceptionArgs
+          # return the  previously assigned edge
+          e.args[:exceptionArgs].split('|').last.load_rid
+        else
+          raise
+        end
+      else
+        raise
+       end
+
     end
 
     def delete

data/lib/model/vertex.rb

@@ -13,45 +13,46 @@ module Arcade
     end
     ## ----------------------------------------- Class Methods------------------------------------ ##
     #                                                                                               #
+
 =begin
-    Vertex.delete fires a "delete vertex" command to the database.
+   Creates a Vertex-Instance.
+   Similar to `Vertex#insert`.
 
-    To remove all records  use  »all: true« as argument
+   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.transmit { "create VERTEX #{database_name} set #{args.map{|x,y| [x,y.to_or].join("=")}.join(', ')+t}" } &.first.allocate_model(false)
+     Api.create_document  db.database, database_name, session_id: db.session,  **args
+    end
 
-    To remove a specific rid, use  rid: "#nn:mmm" as argument
 
-    "where" parameter is optional
+=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
 
-     ExtraNode.delete where: { item: 67  }  == ExtraNode.delete item: 67
+    The "where" parameter is optional
 
+    Example:
+    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"]
+        return db.transmit { "delete from #{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
+      #  puts "delete from  #{database_name} #{compose_where(where)}"
+      db.transmit { "delete  from `#{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
 
 
@@ -71,22 +72,41 @@ module Arcade
       def expand
         self
       end
-    # Supports where:  -->  Strategie.first nodes  where: {size: 10}
-    # "select  both()[ size = 10  ]  from #113:8 "
+    #  ---------------------------------   Nodes   ----------------------------------------------- #
+      #  fetches adjacet nodes
+      #  supported
+      #  nodes  in_or_out =  :in, :out, :both, :inE, :outE
+      #         depth     =  fetch the n'th node through travese
+      #         via:      =  Arcade Database Type (the ruby class)
+      #         where:    =  a condition
+      #                      inE, outE  -->  matches attributes on the edge
+      #                      in, out, both -> matches attributes on the adjacent vertex
+      #  Example  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
+      if depth <= 1
+        s= query.nodes in_or_out, via: via, **args
+        execute ? s.query &.select_result : s
+      else
+       travese in_or_out, depth: depth, start_at: depth-1, via: via, execute: execute, where: args[:where]
+      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
+    def edges in_or_out = :both, depth= 1, via: nil , execute: true
+
+      v = in_or_out.to_s.delete_suffix 'E'
+      e = v + 'E'
+      edge_name = via.nil? ? "" : resolve_edge_name( via )
+      argument =  "#{e}(#{edge_name})"
+      q= if depth > 1
+            repeated_argument = Array.new(depth -1 , "#{v}(#{edge_name})").join(".")
+            query.projection repeated_argument + "." + argument
+         else
+            query.projection  argument
+         end
+      execute ?  q.execute &.allocate_model : q
     end
 
 
@@ -120,17 +140,17 @@ module Arcade
 
     # get via-type-edges  through in
     def inE count=1, via:nil
-      nodes :inE,  count, via: via
+      edges :in,  count, via: via
     end
     #
     # get via-type-edges  through  out
     def outE count=1, via:nil
-      nodes :outE, count,  via: via
+      edges :out, count,  via: via
     end
 
     # get  all via-type-edges
     def bothE  count=1, via:nil
-      nodes :bothE, count, via: via
+      edges :both, count, via: via
     end
 
 
@@ -158,34 +178,33 @@ module Arcade
 			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
+			execute ?  outer_query.execute.allocate_model :  the_query # return only the traverse part
 		end
 
 =begin
 Assigns another Vertex via an EdgeClass. If specified, puts attributes on the edge.
 
+`Vertex.assign via: Edge to: Vertex`
+
 Returns the reloaded assigned vertex
 
 Wrapper for
-  Edge.create in: self, out: a_vertex,  some: attributes.  on: the,  edge: type }
+  Edge.create from: self, to: 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, ... )
+    Vertex.assign() via: E , to: 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
+  def assign vertex: nil , via: Arcade::Edge   , **attributes
+    vertex = attributes[:to] if attributes.has_key? :to
+    raise "vertex not provided" if vertex.nil?
 
     via.create from: self, to: vertex,  **attributes
 
-    db.get vertex.rid  # return the assigned vertex
+    db.get vertex.rid unless vertex.is_a? Array # return the assigned vertex
   rescue IndexError => e
     db.logger.error "Edge not created, already present."
     vertex  #  return the vertex (for chaining)
@@ -205,12 +224,12 @@ Format: < Classname: Edges, Attributes >
 =end
 	def to_human
 
-    in_and_out = -> { "{#{self.in.count}->}{->#{self.out.count }}, " }
+    in_and_out =  "{#{inE.count}->}{->#{outE.count }}, "
 
 		#Default presentation of Arcade::Base::Model-Objects
 
 		"<#{self.class.to_s.snake_case}[#{rid}]:"  +
-      in_and_out[] +
+      in_and_out +
       invariant_attributes.map do |attr, value|
 			v= case value
 				 when  Class

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arcadedb
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.5.0
 platform: ruby
 authors:
 - Hartmut Bischoff
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-25 00:00:00.000000000 Z
+date: 2023-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -144,17 +144,27 @@ files:
 - examples/relation_1__1.rb
 - examples/relation_1__n.rb
 - examples/relation_n_n.rb
+- iruby/.ipynb_checkpoints/01-start-and-end-of-datarows-checkpoint.ipynb
+- iruby/01-start-and-end-of-datarows.ipynb
+- iruby/db-console.rb
 - lib/arcade.rb
 - lib/arcade/api/operations.rb
 - lib/arcade/api/primitives.rb
 - lib/arcade/base.rb
+- lib/arcade/config.rb
 - lib/arcade/database.rb
 - lib/arcade/errors.rb
+- lib/arcade/init.rb
 - lib/arcade/logging.rb
+- lib/arcade/match.rb
+- lib/arcade/query.rb
+- lib/arcade/support/class.rb
+- lib/arcade/support/conversions.rb
+- lib/arcade/support/model.rb
+- lib/arcade/support/object.rb
+- lib/arcade/support/sql.rb
+- lib/arcade/support/string.rb
 - lib/arcade/version.rb
-- lib/config.rb
-- lib/init.rb
-- lib/match.rb
 - lib/model/basicdocument.rb
 - lib/model/basicedge.rb
 - lib/model/basicvertex.rb
@@ -162,13 +172,6 @@ files:
 - lib/model/edge.rb
 - lib/model/vertex.rb
 - lib/models.rb
-- lib/query.rb
-- lib/support/class.rb
-- lib/support/conversions.rb
-- lib/support/model.rb
-- lib/support/object.rb
-- lib/support/sql.rb
-- lib/support/string.rb
 - rails.md
 - rails/arcade.rb
 - rails/config.yml

data/lib/match.rb

@@ -1,216 +0,0 @@
-#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