arcadedb 0.4 → 0.5.2

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,29 +107,57 @@ 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
 
-    # ------------ create  -----------
+    # ------------------------------  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  -----------  ## not supported anymore  by the api
     # returns an rid of the successfully  created vertex or document
     #
     #  Parameter:  name of the vertex or document type
@@ -141,24 +168,38 @@ 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 }"
+        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
 
+
     # ------------------------------  get        ------------------------------------------------------ #
     # Get fetches the record associated with the rid given as parameter.
     #
@@ -178,103 +219,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
+    # ------------------------------  delete     ------------------------------------------------------ #
     #
-    #  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.fatal "Execution  FAILED -->  Status #{e}"
       []  #  return empty result
     end
 
@@ -283,7 +282,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 +291,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 +307,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/{init.rb → arcade/init.rb}

@@ -14,7 +14,8 @@ module Arcade
   #
   class Init
     extend Dry::Core::ClassAttributes
-    defines :db    # database handle
+    defines :db        # database handle
+    defines :models    # static array of database name for arcade-model classes
 
     def self.connect e= :development
 
@@ -25,10 +26,12 @@ module Arcade
              else
                :development
              end
-      #      set the class attribute
 
+      # set the class attributes
+      models Base.descendants.map{|x| x.to_s.split("Arcade::").last }
       db Database.new(env)
     end
+
   end
 
   # Provides method  `db` to every Model class

data/lib/arcade/match.rb

@@ -0,0 +1,210 @@
+module Arcade
+  class Match 
+
+    include Arcade::Support::Sql
+
+=begin
+  This is a 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]
+  Customize the return values:
+               b.to_s{ "customized return statement" }
+               b.execute{ "customized return statment" }
+               
+  Conditions on edges:
+        m =  Match.new type: Arcade::DatabaseType
+        m.inE via: Arcade::Edge  || via: [Arcade::Edge1, Arcade::Edge2], where: { var: 3..6 }  
+         --->  inE('edge(1)'){ where: (var between 3 and 6 )}.outV('edge(2)')
+
+  Address a single database record:
+        m = Match.new( vertex: { Arcade::Vertex-Instance } )
+            .....
+            .node( vertex: { Arcade::Vertex-Instance } )     # instead of where statement           
+
+  Example
+
+   symbol_or_title =  symbol.present? ? { :symbol => symbol } : { :title => title }
+   where = { :right => right }
+
+   a= Arcade::Match.new( type: self.class, where: symbol_or_title )
+                   .out( Arcade::HasContract )
+                   .node( as: :c, where: where )
+   a.execute do "c.last_trading_day as expiry,         # c is returned form the query [as: :c]                                               
+                 count(c) as contracts,
+                 min(c.strike) as s_min,
+                 max(c.strike) as s_max
+                 group by c.last_trading_day order by c.last_trading_day"
+             end
+
+
+=end
+
+    def initialize  **args
+      type = args.delete :type
+      vertex =  args.delete :vertex
+      rid =  args.delete :rid
+      raise "MATCH#new:: parameter rid is not supported. Use `vertex: Arcade::Vertex.instance` instead." if rid.present?
+      @args = args
+      @as = []
+
+      @stack = if vertex.is_a?( Arcade::Vertex ) && args.empty?
+         [ "MATCH { type: #{vertex.class.database_name }, rid: #{vertex.rid} }" ]
+               elsif  vertex.is_a?( Arcade::Vertex ) 
+         [ "MATCH { type: #{vertex.class.database_name }, rid: #{vertex.rid}, #{ assigned_parameters } }" ]
+               elsif  type.is_a?( Class) && type.ancestors.include?(Arcade::Vertex) && args.empty?
+         [ "MATCH { type: #{type.database_name} }" ]
+               elsif  type.is_a?( Class) && type.ancestors.include?(Arcade::Vertex)
+         [ "MATCH { type: #{type.database_name}, #{ assigned_parameters } }" ]
+               else
+         raise "Match:: Either type  (Arcade::Vertex-Class) or vertex (Arcade::Vertex-Object) is required as parameter"
+               end
+
+      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
+
+
+
+    def self.define_base_edge *direction
+      direction.each do | e_d |
+        define_method e_d do | edge = "" |
+          raise "edge must be a Database-class" unless edge.is_a?(Class) || edge.empty?
+          @stack << ".#{ e_d  }(#{edge.is_a?(Class) ? edge.database_name.to_or : ''})"
+          self
+        end
+      end
+    end
+
+
+    # add conditions on  edges to the match statement
+    def self.define_inner_edge start_dir, final_dir
+      define_method start_dir do | edge = "", **a |
+        raise "edge must be a Database-class"  unless edge.is_a?(Class) || edge.empty?
+
+        print_edges = -> (e){ e.is_a?(Class) ? e.database_name.to_or : ''}
+        edges = [ a.delete(:via) ].flatten
+        edges << edge unless edge == ''
+        n = if a.empty?
+              ""
+            else
+              @args = a
+              "{ #{ assigned_parameters } }"
+            end
+        @stack << ".#{ start_dir }(#{print_edges.call(edges.first)})#{ n }.#{ final_dir }(#{print_edges.call(edges.last)})"
+        return self
+      end
+
+    end
+
+    define_base_edge :out, :in, :both
+    define_inner_edge :inE, :outV
+    define_inner_edge :outE, :inV
+
+
+
+    # general declation of a node (ie. vertex)
+    def node **args
+      vertex =  args.delete :vertex
+      rid =  args.delete :rid
+      raise "MATCH#node:: parameter rid is not supported. Use `vertex: Arcade::Vertex.instance` instead." if rid.present?
+      @args = args
+      @stack << if args.empty?
+       vertex.present? ? "{ type: #{vertex.class.database_name }, rid: #{vertex.rid} }" : "{}"
+                else
+       vertex.present? ? "{ type: #{vertex.class.database_name }, rid: #{vertex.rid}, #{assigned_parameters} }" :  "{ #{ 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