arcadedb 0.4 → 0.5.2

data/lib/{query.rb → arcade/query.rb}

@@ -27,7 +27,8 @@ module Arcade
 								[],   # aliases
 								'',  # database
 								[],   #set,
-								[]  # remove
+								[],  # remove
+							  []   # group by
 			  args.each{|k,v| send k, v}
 				@fill = block_given? ?   yield  : 'and'
 		end
@@ -62,12 +63,10 @@ module Arcade
 			@q[:kind]
 			end
 		end
-=begin
-  Output the compiled query
-  Parameter: destination (rest, batch )
-  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
-=end
-
+    # ------------------ compose---------------------------------------
+    #  Output the compiled query
+    #  Parameter: destination (rest, batch )
+    #  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
 		def compose(destination: :batch)
 			if kind.to_sym == :update
 				return_statement = "return after " + ( @q[:aliases].empty? ?  "$current" : @q[:aliases].first.to_s)
@@ -110,21 +109,24 @@ module Arcade
 										' ( '+ the_argument.compose + ' ) '
 									when Class
 										the_argument.database_name
-									else
+                  when Arcade::Match
+                    '(' + the_argument.to_s + ')'
+                  when String
 										if the_argument.to_s.rid?	  # a string with "#ab:cd"
 											the_argument
-										else		  # a database-class-name
+                    else
+                      '(' + the_argument + ')'
+                    end
+                  else		  # a database-class-name
 											the_argument.to_s
-										end
 									end
 			else
 				raise "cannot complete until a target is specified"
 			end
 		end
 
-=begin
-	from can either be a Databaseclass to operate on or a Subquery providing data to query further
-=end
+	# -------------------- from ---------------------------------------
+	#  arg  can either be a Database class to operate on or a Subquery providing data to query further
 		def from arg = nil
 			if arg.present?
 				@q[:database] =  arg
@@ -311,27 +313,36 @@ end # class << self
 			self
     end
 
-		# connects by adding {in_or_out}('edgeClass')
-		def connect_with in_or_out, via: nil
-			 argument = " #{in_or_out}(#{via.to_or if via.present?})"
-		end
+
+    # ------------------ nodes ---------------------------------------
 		# adds a connection
-		#  in_or_out:  :out --->  outE('edgeClass').in[where-condition]
-		#              :in  --->  inE('edgeClass').out[where-condition]
+		#  in_or_out:  :out  --->  out('edgeClass')[where-condition]
+		#              :in   --->  in('edgeClass')[where-condition]
+    #              :inE  --->  inE('edgeClass')[where-condition].outV()
+    #              :outE --->  outE('edgeClass')[where-condition].inV()
+    #
+    #  via:        Edge-Class
+    #  where:      Condition to be applied on the targed vertex (in_or_out = :in, :out, :both)
+    #                                or on the intermitted edge (in_or_out =  :inE, :outE, :bothE)
+    #              Condition is inserted as "in_or_out[ condition ]"
+    #  Attention: ranges have to be included as array, ie [ 2..4 ]
+    #
 
 		def nodes in_or_out = :out, via: nil, where: nil, expand:  false
 
-			 condition = where.present? ?  "[ #{generate_sql_list(where)} ]" : ""
+			 condition = where.present? ? "[ #{generate_sql_list(where)} ]" : ""
        via = resolve_edge_name(via) unless via.nil?
 
-       start =  if in_or_out.is_a? Symbol
-                  in_or_out.to_s
-                elsif in_or_out.is_a? String
-                  in_or_out
-								else
-									"both"
-								end
-			 argument = " #{start}(#{via})#{condition} "
+       argument = if in_or_out.to_s[-1] == 'E'
+                    case in_or_out.to_s[0..-2]
+                    when 'in'
+                      "inE(#{via})#{condition}.outV()"
+                    when 'out'
+                      "outE(#{via})#{condition}.inV()"
+                    end
+                  else
+                    "#{in_or_out.to_s}(#{via})#{condition}"
+                  end
 
 			 if expand.present?
 				 send :expand, argument
@@ -349,7 +360,7 @@ end # class << self
 		# returns nil if the query was not sucessfully executed
 		def execute(reduce: false, autoload: true )
 #      unless projection.nil?    || projection.empty?
-      result = db.execute { compose }
+      result = db.transmit { compose }
 			return nil unless result.is_a?(Array)
 			block_given?  ? result.map{|x| yield x }  : result
 #			return  result.first if reduce && result.size == 1

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

@@ -63,6 +63,7 @@ module Arcade
       #
 
       def select_result condition=nil
+        return [] if self.empty?
         condition = first.keys.first if condition.nil?
         map{|x| x[condition.to_sym]}.flatten.allocate_model
       end

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

@@ -15,42 +15,42 @@ module Arcade
         end.join(',')
       end
 
-
     #  used by array#allocate_model
       def _allocate_model response=nil, auto = Config.autoload
 
-
       if response.is_a? Hash
         # save rid to a safe place
-        temp_rid = response.delete :"@rid"
-        type           = response.delete :"@type"
-        cat            = response.delete :"@cat"
+        temp_rid = response.delete( :"@rid"  ) || response.delete( :rid ) || "#0:0"
+        type     = response.delete( :"@type" ) || response.delete( :type )  || nil
+        cat      = response.delete( :"@cat"  ) || response.delete( :cat )  || "d"
 
         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|
+          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
-              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
+              a =[]
+              x.map do | y |
+                # Thread.new do  ## using thread or fiber decreases the performance significantly.
+                  if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
+                    _allocate_model(y,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 +60,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 +74,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/{support → arcade/support}/sql.rb

@@ -44,7 +44,7 @@ If »NULL« should be addressed, { key: nil } is translated to "key = NULL"  (us
           attributes.map do |key, value|
             case value
             when nil
-              "#{key}=NULL"
+              "#{key} is NULL"
             when ::Array
               if value == [nil]
                 "#{key} is NULL"

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

@@ -11,9 +11,12 @@ module Arcade
           delimiters = Regexp.union(['-', '_'])
           n,c= self.split(delimiters).then { |first, *rest| [first.tap {|s| s[0] = s[0].upcase}, rest.map(&:capitalize).join]  }
           ## if base is the first part of the type-name, probably Arcade::Base is choosen a namespace. thats wrong
-          namespace_present = unless n == 'Base'
+          # Arcade::Base descendants are prefetched in Init.models
+          # They have to be fetched to  load both  `Arcade::Ge` and `Arcade::GeSomething`
+          #                (otherwise: Arcade::Ge and Arcade::Ge::Something)
+          namespace_present = unless n == 'Base'  ||  Arcade::Init.models.include?(n)
                                 Object.const_get(n)  rescue  false # Database.namespace
-                              else 
+                              else
                                 false
           end
           # if no namespace is found, leave it empty and return the capitalized string as class name
@@ -22,6 +25,10 @@ module Arcade
           [ Database.namespace, self.capitalize ]
         end
       end
+      def camelcase
+      # Split the string into words, capitalize each word, and join them together
+        self.split('_').map(&:capitalize).join
+      end
 
       def snake_case
         n= if split('::').first == Database.namespace.to_s
@@ -51,7 +58,7 @@ module Arcade
       end
 #  return a valid rid (format: "nn:mm") or nil
       def rid
-        self["#"].nil? ? "#"+ self : self if rid? 
+        self["#"].nil? ? "#"+ self : self if rid?
       end
 
       def where **args
@@ -80,7 +87,7 @@ module Arcade
       ## Load the database object if the string is a rid
       # (Default: No Autoloading of rid-links)
       def load_rid autocomplete = false
-        db.get( self ){  autocomplete }  if rid?  rescue nil
+        db.get( self.strip ){  autocomplete }  if rid?  rescue nil
       end
 
       # updates the record    ### retired in favour of Arcade::Base.update
@@ -104,13 +111,3 @@ module Arcade
 end
 
 String.include Arcade::Support::String
-
-module Types
-  include Dry.Types()
-
-  # include in attribute definitions
-  Rid = String.constrained( format:  /\A[#]{1}[0-9]{1,}:[0-9]{1,}\z/ )
-  Blockchain =  String.constrained( format: /^(algo|eth|btc)$/ )  #  add other blockchain symbols here
-  Email = String.constrained( format: /\A[\w+\-.]+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i )
-
-end

data/lib/arcade/version.rb

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

data/lib/arcade.rb

@@ -9,28 +9,29 @@ require "dry/core/class_builder"
 require "dry/core/class_attributes"
 require 'json'
 
-module Types
-  include Dry.Types()
-end
+require_relative '../lib/types'
+#module Types
+#  include Dry.Types()
+#end
 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/errors'
 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" 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,8 +13,37 @@ 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
 
+
+    ## class-method: Delete Edge between two vertices
+    ##
+    ## returns the count of deleted edges
+    ##
+    ## todo: add conditions
+    def self.delete from:, to:
+      return 0 if from.nil? || to.nil?
+      raise "parameter ( from: ) must be a String or a Vertex" unless from.is_a?(String) || from.is_a?( Arcade::Vertex)
+      raise "parameter ( to: ) must be a String or a Vertex" unless to.is_a?(String) || to.is_a?( Arcade::Vertex)
+      raise "parameters (from: + to:) must respond to `.rid`" unless from.respond_to?( :rid) && to.respond_to?(:rid)
+
+      db.execute{ "delete edge from #{from.rid} to #{to.rid} " } &.select_result &.first
+    end
+
+
+    ## instance method: Delete specified edge
     def delete
       db.execute{  "delete edge #{ rid }" }.select_result
     end

data/lib/model/revision.rb

@@ -0,0 +1,41 @@
+module Arcade
+  class  Revision < Arcade::Vertex
+    attribute :protocol?, Types::Nominal::Array
+
+    @@u='root'  # default user
+    @@i = 'Record initiated'
+
+  def self.set_user u
+    @@u = u
+  end
+
+  def self.set_initial_message m
+    @@i = m
+  end
+
+  def self.insert **attr
+
+    action = block_given? ?  yield : @@i
+    i= super **attr
+    i.update_list :protocol,
+                   Arcade::RevisionRecord.create( user: @@u, action: action ),
+                   modus: :first
+    i.refresh
+
+  end
+
+
+  def update **attr
+    hist_state =  attr.keys.map do |k|
+                  [ k,  send( k ) ]
+    end.to_h
+    super **attr
+    revision = if block_given?
+         Arcade::RevisionRecord.create( user: @@u, action: yield,  fields: hist_state )
+               else
+                 Arcade::RevisionRecord.create( fields: hist_state )
+               end
+    update_list :protocol, revision, modus: :append
+  end
+  end
+end

data/lib/model/revision_record.rb

@@ -0,0 +1,29 @@
+module Arcade
+  class RevisionRecord  < Document
+    attribute  :user, Types::Nominal::String.default( 'root'.freeze )
+    attribute  :action, Types::Nominal::String.default( "Property changed".freeze )
+    attribute  :date, Types::Nominal::Date.default( Date.today.freeze )
+    attribute  :fields?, Types::Nominal::Hash
+
+   #  Revision Records are always embedded.
+   #  create and insert methods return an new ruby record
+   def self.create **attr
+     new **( { rid: '#0:0', date: Date.today}.merge attr )
+   end
+   def self.insert **attr
+     new **( { rid: '#0:0', date: Date.today}.merge **attr )
+   end
+
+=begin
+  Its not allowed to delete records.
+=end
+    def self.delete where: {} , **args
+      raise ArcadeQueryError, "Its not possible to delete revision records"
+    end
+
+    def delete
+      raise ArcadeQueryError, "Its not possible to delete revision records"
+    end
+
+  end
+end