arcadedb 0.4 → 0.5.0

data/lib/arcade/database.rb

@@ -17,12 +17,12 @@ module Arcade
     defines :environment
 
     def initialize  environment=:development
-      self.class.configure_logger( Config.logger ) 
-      @connection =  connect environment
+      self.class.configure_logger( Config.logger )
       if self.class.environment.nil?    # class attribute is set on the first call
                                         # further instances of Database share the same environment
         self.class.environment  environment
       end
+      @session_id = nil #  declare session_id
       self.class.namespace  Object.const_get( Config.namespace )
     end
 
@@ -39,20 +39,19 @@ module Arcade
     #
     def types refresh=false
       #  uses API
-      if $types.nil? || refresh
-       $types = Api.query(database, "select from schema:types"   )
-                   .map{ |x| x.transform_keys &:to_sym     }   #  symbolize keys
-                   .map{ |y| y.delete_if{|_,b,| b.empty? } }   #  eliminate  empty entries
+      if @types.nil? || refresh
+       @types = Api.query(database, "select from schema:types"   )
+                   .map{ |y| y.delete_if{|_,b,| b.blank? } }   #  eliminate  empty entries
       end
-      $types
-      ## upom startup, this is the first access to the database-server
+      @types
+      ## upon startup, this is the first access to the database-server
     rescue NoMethodError => e
       logger.fatal "Could not read Database Types. \n Is the database running?"
       Kernel.exit
     end
 
-    def indexes
-      DB.types.find{|x| x.key? :indexes }[:indexes]
+    def indexes refresh=false
+      types(refresh).find_all{|x| x.key? :indexes }.map{|y| y[:indexes]}.flatten
     end
 
     # ------------ hierarchy -------------
@@ -108,28 +107,56 @@ module Arcade
           "create edge type #{type} "
         end.concat( args.map{|x,y| "#{x} #{y} "}.join)
       end
-      db= Api.execute database, &exe
+      dbe= Api.execute database, &exe
       types( true )  # update cached schema
-      db
-
-    rescue HTTPX::HTTPError => e
-#      puts "ERROR:  #{e.message.to_s}"
-      if e.status == 500 && e.message.to_s =~ /already exists/
-        Arcade::Database.logger.warn "Database type #{type} already present"
-      else
-        raise
-      end
+      dbe
+
+    rescue Arcade::QueryError => e
+       if e.message  =~/Type\s+.+\salready\s+exists/
+        Arcade::Database.logger.debug "Database type #{type} already present"
+       else
+         raise
+       end
     end
 
     alias create_class create_type
 
     # ------------ drop type  -----------
     #  delete any record prior to the attempt to drop a type.
-    #  The `unsafe` option is nit implemented.
+    #  The `unsafe` option is not implemented.
     def drop_type  type
       Api.execute database, "drop type #{type} if exists"
     end
 
+    # ------------------------------  transaction ----------------------------------------------------- #
+    #  Encapsulates simple transactions
+    #
+    #  nested transactions are not supported.
+    #  * use the low-leve api.begin_tranaction for that purpose
+    #  * reuses an existing transaction
+    #
+    def begin_transaction
+      @session_id ||= Api.begin_transaction database
+    end
+    # ------------------------------  commit      ----------------------------------------------------- #
+    def commit
+     r = Api.commit( database, session_id: session)
+      @session_id = nil
+     true if r == 204
+     end
+
+    # ------------------------------  rollback    ----------------------------------------------------- #
+    #
+    def  rollback
+     r = Api.rollback( database, session_id: session)
+     @session_id = nil
+     true if r == 500
+    rescue HTTPX::HTTPError => e
+      raise
+     end
+
+
+
     # ------------ create  -----------
     # returns an rid of the successfully  created vertex or document
     #
@@ -141,21 +168,34 @@ module Arcade
     #
     def create type, **params
       #  uses API
-      Api.create_document database, type,  **params
+      Api.create_document database, type,  session_id: session, **params
     end
 
+    # ------------------------------  insert     ------------------------------------------------------ #
+    #
+    # translates the given parameters to
+    # INSERT INTO [TYPE:]<type>|BUCKET:<bucket>|INDEX:<index>
+    #   [(<field>[,]*) VALUES (<expression>[,]*)[,]*]|
+    #   [CONTENT {<JSON>}|[{<JSON>}[,]*]]
+    #
+    #   :from and :return are not supported
+    #
+    # If a transaction is active, the insert is executed in that context.
+    # Nested transactions are not supported
     def insert  **params
 
-      content_params = params.except( :type, :bucket, :index, :from, :return )
+      content_params = params.except( :type, :bucket, :index, :from, :return, :session_id )
       target_params = params.slice( :type, :bucket, :index )
+#      session_id = params[:session_id]   # extraxt session_id  --> future-use? 
       if  target_params.empty?
-        logger.error "Could not insert: target mising (type:, bucket:, index:)"
+        raise "Could not insert: target missing (type:, bucket:, index:)"
       elsif content_params.empty?
         logger.error "Nothing to Insert"
       else
         content =  "CONTENT #{ content_params.to_json }"
         target =  target_params.map{|y,z|  y==:type ?  z : "#{y.to_s} #{ z } "}.join
-        Api.execute( database, "INSERT INTO #{target} #{content} ") &.first.allocate_model(false)
+        result = Api.execute( database, session_id: session ){ "INSERT INTO #{target} #{content} "}
+        result &.first.allocate_model(false)
       end
     end
 
@@ -178,103 +218,61 @@ module Arcade
       rid =  rid.join(':')
       rid = rid[1..-1] if rid[0]=="#"
       if rid.rid?
-        Api.query( database, "select from #{rid}" ).first &.allocate_model(autocomplete)
+        Api.query( database, "select from #{rid}", session_id: session ).first &.allocate_model(autocomplete)
       else
         raise Arcade::QueryError "Get requires a rid input", caller
       end
     end
 
-    # ------------------------------  property        ------------------------------------------------- #
-    # Adds properties to the type
+    # ------------------------------  get        ------------------------------------------------------ #
     #
-    #  call via
-    #  Api.property <database>, <type>, name1: a_format , name2: a_format
+    #  Delete the specified rid
     #
-    #  Format is one of
-    #   Boolean, Integer, Short, Long, Float, Double, String
-    #   Datetime, Binary, Byte, Decimal, Link
-    #   Embedded, EmbeddedList, EmbeddedMap
+    def delete rid
+      r =  Api.execute( database, session_id: session ){ "delete from #{rid}" }
+      success =  r == [{ :count => 1 }]
+    end
+
+    # ------------------------------  transmit   ------------------------------------------------------ #
+    # transmits a command  which potentially modifies the database
     #
-    #   In case of an Error,  anything is rolled back and nil is returned
+    # Uses the given session_id for transaction-based operations
     #
-    def self.property database, type, **args
-
-      begin_transaction database
-      success = args.map do | name, format |
-        r= execute(database) {" create property #{type.to_s}.#{name.to_s} #{format.to_s} " } &.first
-        if r.nil?
-          false
-        else
-          r.keys == [ :propertyName, :typeName, :operation ] && r[:operation] == 'create property'
-        end
-      end.uniq
-      if success == [true]
-        commit database
-        true
+    # Otherwise just performs the operation
+
+    def transmit   &block
+      response = Api.execute database,  session_id: session, &block
+      if  response.is_a? Hash
+           _allocate_model res
       else
-        rollback database
+           response
       end
-
-
-    end
-
-    # ------------------------------ index            ------------------------------------------------- #
-    def self.index database, type,  name ,  *properties
-      properties = properties.map( &:to_s )
-      unique_requested = "unique" if properties.delete("unique")
-      unique_requested = "notunique" if  properties.delete("notunique" )
-      automatic = true if
-      properties << name  if properties.empty?
-    end
-
-    def delete rid
-      r =  Api.execute( database ){ "delete from #{rid}" }
-      success =  r == [{ :count => 1 }]
     end
-
+    # ------------------------------  execute    ------------------------------------------------------ #
     # execute a command  which modifies the database
     #
     # The operation is performed via Transaction/Commit
     # If an Error occurs, its rolled back
     #
+    # If a transaction is already active, a nested transation is initiated
+    #
     def execute   &block
-      s = Api.begin_transaction database
-  #    begin
-      response = Api.execute database, nil, s, &block
-    #  rescue HTTPX::HTTPError => e
-    #    raise e.message
-    #    puts  e.methods
-    #    puts e.status
-    #    puts e.response
-    #    puts e.message
-    #    puts e.exception
-    #    puts e.cause
-    #  end
-      # puts response.inspect  # debugging
+      # initiate a new transaction
+     s= Api.begin_transaction database
+      response = Api.execute database,  session_id: s,  &block
       r= if  response.is_a? Hash
-           _allocate_model res
-#         elsif response.is_a? Array
-           # remove empty results
-#           response.delete_if{|y| y.empty?}
-          # response.map do | res |
-          #   if res.key? :"@rid"
-          #     allocate_model res
-          #   else
-          #     res
-          #   end
-          # end
+           _allocate_model response
          else
            response
          end
-     if Api.commit( database, s) == 204
+     if Api.commit( database, session_id: s) == 204
         r # return associated array of Arcade::Base-objects
      else
        []
      end
-    rescue  Dry::Struct::Error, HTTPX::HTTPError, Arcade::QueryError => e
-      Api.rollback database, s
-      logger.error "Execution  FAILED -->  Status #{e.status}"
- #     logger.error "Execution  FAILED --> #{e.exception.message}"
+    rescue  Dry::Struct::Error, Arcade::QueryError => e
+      Api.rollback database, session_id: s, log: false
+      logger.info "Execution  FAILED -->  Status #{e.status}"
       []  #  return empty result
     end
 
@@ -283,7 +281,7 @@ module Arcade
     # detects database-records and  allocates them as model-objects
     #
     def query  query_object
-      Api.query database, query_object.to_s
+      Api.query database, query_object.to_s, session_id: session
     end
 
     #  returns an array of rid's   (same logic as create)
@@ -292,20 +290,12 @@ module Arcade
       content = attributes.empty? ?  "" : "CONTENT #{attributes.to_json}"
       cr = ->( f, t ) do
         begin
-        edges = Api.execute( database, "create edge #{edge_class} from #{f.rid} to #{t.rid} #{content}").allocate_model(false)
-        rescue HTTPX::HTTPError => e
-         # if e.status == 503
-         #   puts e.status
-         # puts e.message
-         # puts e.message.class
-         # end
+          cmd = -> (){  "create edge #{edge_class} from #{f.rid} to #{t.rid} #{content}" }
+        edges = transmit( &cmd ).allocate_model(false)
+        rescue Arcade::QueryError => e
           raise unless e.message =~ /Found duplicate key/
-         puts "#"+e.message.split("#").last[0..-3]
+         puts "#"+e.detail.split("#").last[0..-3]
         end
-        #else
-        #  logger.error "Could not create Edge  #{edge_class} from #{f} to #{t}"
-        ##  logger.error edges.to_s
-        #end
       end
       from =  [from] unless from.is_a? Array
       to =  [to] unless to.is_a? Array
@@ -316,52 +306,12 @@ module Arcade
 
     end
 
-
-    # query all:  select @rid, *  from {database}
-
-#  not used
- #  def get_schema
- #    query( "select from schema:types" ).map do |a|
- #      puts "a: #{a}"
- #      class_name = a["name"]
- #      inherent_class =  a["parentTypes"].empty? ? [Object,nil] : a["parentTypes"].map(&:camelcase_and_namespace)
- #       namespace, type_name = a["type"].camelcase_and_namespace
- #       namespace= Arcade if namespace.nil?
- #      klass=  Dry::Core::ClassBuilder.new(  name: type_name,
- #                                          parent: nil,
- #                                          namespace:  namespace).call
- #    end
- #  rescue NameError
- #    logger.error "Dataset type #{e} not defined."
- #    raise
- #  end
-   #  Postgres is not implemented
-   # connects to the database and initialises @connection
-    def connection
-      @connection
+    def session
+      @session_id
     end
 
-    def connect environment=:development   # environments:  production devel test
-      if [:production, :development, :test].include? environment
-
-        #  connect through the ruby  postgres driver
-#       c= PG::Connection.new  dbname: Config.database[environment],
-#         user: Config.username[environment],
-#         password: Config.password[environment],
-#         host:  Config.pg[:host],
-#         port:  Config.pg[:port]
-#
-     end
-    rescue PG::ConnectionBad => e
-      if e.to_s  =~  /Credentials/
-        logger.error  "NOT CONNECTED ! Either Database is not present or credentials (#{ Config.username[environment]} / #{Config.password[environment]}) are wrong"
-        nil
-      else
-        raise
-      end
-    end  # def
-
-
-
+    def session?
+      !session.nil?
+    end
   end  # class
 end  #  module

data/lib/arcade/errors.rb

@@ -22,6 +22,14 @@ module Arcade
   end
 
   class QueryError < RuntimeError
+    attr_reader :error, :args
+    def initialize  error: "", detail: "", exception: "", **args
+      @error = error
+#      @detail = detail
+      @args = args
+      @exception = exception
+      super detail
+    end
   end
 
   # used by Dry::Validation,  not covered by "error"

data/lib/arcade/match.rb

@@ -0,0 +1,162 @@
+module Arcade
+  class Match 
+
+    include Arcade::Support::Sql
+
+=begin
+  This is a very simple wrapper for the match statement
+
+  Initialize:  a= Arcade::Match.new type: Arcade::DatabaseType, where: { property: 'value' }, as: :alias
+  Complete:    b = a.out( Arcade::EdgeType ).node( while: true, as: item )[ .in.node ... ]
+  Inspect      b.to_s
+  Query DB     b.execute [.allocate_model]
+                         [.analyse_result]
+
+=end
+
+    def initialize type: , **args
+
+      @args = args
+      @as = []
+
+      @stack = [ "MATCH { type: #{type.database_name}, #{ assigned_parameters } }" ]
+
+      return self
+    end
+
+    # Inspect the generated match statement
+    def to_s &b
+      r = ""
+      r = "DISTINCT " if @distinct
+      r << @as.join(",")
+      r= yield(r) if block_given?
+      @stack.join("") + " RETURN #{r} "
+    end
+
+
+    # Execute the @stack
+    # generally followed by `select_result` to convert json-hashes  to arcade objects
+    #
+    # The optional block  modifies the result-statement
+    # i.e
+    # TG::TimeGraph.grid( 2023, 2..9  ).out(HasPosition)
+    #                                  .node( as: :contract  )
+    #                                  .execute { "contract.symbol"  }
+    #                                  .select_result
+    # gets all associated contracts connected to the month-grid
+    def execute &b
+      Arcade::Init.db.query( to_s( &b ) )
+    end
+
+
+    # todo : metaprogramming!
+    def out edge=""
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".out(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
+      return self
+    end
+    def in edge=""
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".in(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
+      return self
+    end
+    def both edge=""
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".both(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
+      return self
+    end
+
+    # add conditions on  edges to the match statement
+    def inE edge="", **args
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".inE(#{edge.is_a?(Class) ? edge.database_name.to_or : ''}) #{assigned_parameters}.outV()"
+      return self
+    end
+    def outE edge="", **args
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".outE(#{edge.is_a?(Class) ? edge.database_name.to_or : ''}) #{assigned_parameters}.inV()"
+      return self
+    end
+    def bothE edge="", **args
+      raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+      @stack << ".bothE(#{edge.is_a?(Class) ? edge.database_name : ''}) #{assigned_parameters}.bothV()"
+      return self
+    end
+
+
+    # general declation of a node (ie. vertex)
+    def node **args
+      @args = args
+      @stack << if args.empty?
+       "{}"
+              else
+       "{ #{ assigned_parameters } }"
+              end
+      return self
+    end
+
+
+
+    ### ---------------- end of public api ---------------------------------------------------------------- ### 
+    private
+
+
+    def assigned_parameters
+      @args.map do | k, v |
+      #  unless k == :while  #  mask ruby keyword
+        send k, v
+      #  else
+      #   the_while v
+      #  end
+      end.compact.join(', ')
+
+    end
+
+    ##  Metastatement     ----------  last  --------------------
+    ##
+    ## generates a node declaration  for fetching the last element of a traversal on the previous edge
+    ##
+    ## ie:    Arcade::Match.new( type: self.class, where: { symbol: symbol  } ).out( Arcade::HasContract  )
+    #                                                                          .node( as:  :c, where: where  )
+    #                                                                          .in( Arcade::IsOrder  )
+    #                                                                          .node( last: true, as: :o  )
+    #
+    #  --> ... }.in('is_order'){ while: (in('is_order').size() > 0), where: (in('is_order').size() == 0), as: o  }
+    def last  arg
+      in_or_out = @stack[-1][1..-1]   # use the last statement
+      "while: ( #{in_or_out}.size() > 0  ), where: (#{in_or_out}.size() == 0)"
+    end
+
+    def distinct arg
+      @distinct = true
+    end
+
+
+    def where arg
+      "where: ( #{ generate_sql_list( arg  )  } )" unless arg.empty?
+    end
+
+    def while arg
+      if arg.is_a? TrueClass
+         "while: ( true )"
+       else
+       "while: ( #{ generate_sql_list( arg  ) } )"
+       end
+    end
+
+    def maxdepth arg
+      "maxDepth: #{arg}"
+    end
+
+    def as arg
+      @as << arg
+      "as: " + arg.to_s
+    end
+
+    def type klassname
+      raise "type must be a Database-class"  unless klassname.is_a? Class
+      "type: #{klassname.database_name}"
+    end
+
+  end
+end

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

@@ -110,12 +110,16 @@ 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"
@@ -311,27 +315,39 @@ 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
+#		# 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
+
 		# 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)} ]" : ""
        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 +365,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