arcadedb 0.3.1 → 0.3.3

data/examples/relation_n_n.rb

@@ -0,0 +1,194 @@
+##
+## This example realises a bidirectional 1:n relation using Edges & Vertices
+#
+## The schema is implemented in modelfiles located in spec/model
+## /spec/models/ex/human.rb             #  Vertex
+## /spec/models/ex/depend_on.rb         #  Edge
+#
+#  This script runs in the test environment.
+##
+require 'bundler/setup'
+require 'zeitwerk'
+require 'arcade'
+
+include Arcade
+## require modelfiles
+loader =  Zeitwerk::Loader.new
+loader.push_dir ("#{__dir__}/../spec/model")
+loader.setup
+
+## clear test database
+
+databases =  Arcade::Api.databases
+if  databases.include?(Arcade::Config.database[:test])
+  Arcade::Api.drop_database Arcade::Config.database[:test]
+end
+Arcade::Api.create_database Arcade::Config.database[:test]
+
+## Universal Database handle
+DB = Arcade::Init.connect 'test'
+
+## ------------------------------------------------------ End Setup ------------------------------------- ##
+##
+## We are realising  a self referencing  relation
+## parent  <-->   children
+#
+
+
+Ex::Human.create_type                                                             # initialize the database
+Ex::DependOn.create_type
+
+nodes = %w( Guthorn Fulkerson Sniezek Tomasulo Portwine Keala Revelli Jacks Gorby Alcaoa ).map do | name |
+  Ex::Human.insert name: name, birth: 2022 - rand(99), married: rand(2)==1
+end
+
+puts Ex::Human.count.to_s + " Human Vertices created"
+
+puts "------------------------------ get a sorted list of married humans ---------------------------------"
+puts
+
+merried = Ex::Human.query( where: { married: true })
+merried.order 'birth'
+new_merried = Query.new projection: 'name, 2022-birth as age ', from: merried          #  merge two queries
+puts new_merried.query
+
+puts "------------------------------ and one for not married humans      ---------------------------------"
+puts
+
+singles = Ex::Human.query( where: { married: false })
+singles.order 'birth'
+new_singles = Query.new projection: 'name, 2022-birth as age ', from: singles          #  merge two queries
+puts new_singles.query
+
+
+puts "------------------------------ connect  married humans  with children ------------------------------"
+children = singles.query.allocate_model
+
+begin
+  children_enumerator =  children.each
+  merried.query.allocate_model.map do | parent |
+    parent.assign via: Ex::DependOn, vertex: children_enumerator.next
+  end
+rescue StopIteration
+   puts "No more children"
+end
+
+# Ex::Human.parents is essential
+#    EX::Human.query projection: 'out()' , whee: { married: true }
+# Ex::Human.children is essential
+#    EX::Human.query projection: 'out()' , whee: { married: true }
+puts "--------------------------- Parent and Children ---------------------------------------------------"
+puts
+puts "%10s  %7s %10s %30s " % ["Parent", "Age", "Child", "sorted by Child"]
+puts "- " * 50
+Ex::Human.parents( order: 'name' ).each  do |parent|                          # note: order: 'name' is included
+                                                                              # in the query
+  puts "%10s  %7d %10s  " % [parent.name, 2022 - parent.birth, parent.out.first.name]
+end
+
+puts "--------------------------- child and parent  -----------------------------------------------------"
+puts
+puts "%10s  %7s %10s %30s " % ["Child", "Age", "Parent", "sorted by Parent"]
+puts "- " * 50
+Ex::Human.children( order: 'name' ).each  do |child|
+  puts "%10s  %7d %10s  " % [child.name, 2022 - child.birth, child.in.first.name]
+end
+
+puts "--------------------------- Add  child to a parent  -----------------------------------------------"
+puts
+
+Ex::Human.parents.first.assign via: Ex::DependOn, vertex:  Ex::Human.insert( name: "TestBaby", birth: 2022, married: false)
+
+puts "Parent: " +  Ex::Human.parents.first.to_human
+puts "Children: \n " + Ex::Human.parents.first.out.to_human.join("\n ")
+
+## Expected output
+__END__
+
+Using default database credentials and settings fron /home/ubuntu/workspace/arcadedb
+27.04.(18:35:05) INFO->Q: create vertex type ex_human 
+27.04.(18:35:05) INFO->Q: CREATE PROPERTY ex_human.name STRING
+27.04.(18:35:05) INFO->Q: CREATE PROPERTY ex_human.married BOOLEAN
+27.04.(18:35:05) INFO->Q: CREATE INDEX `Example[human]` ON ex_human ( name  ) UNIQUE
+27.04.(18:35:05) INFO->Q: create edge type ex_depend_on 
+27.04.(18:35:05) INFO->Q: CREATE INDEX depends_out_in ON ex_depend_on  (`@out`, `@in`) UNIQUE
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Guthorn","birth":1962,"married":false} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Fulkerson","birth":1962,"married":true} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Sniezek","birth":1972,"married":true} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Tomasulo","birth":1953,"married":false} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Portwine","birth":1975,"married":true} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Keala","birth":1961,"married":false} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Revelli","birth":1948,"married":true} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Jacks","birth":1993,"married":true} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Gorby","birth":1979,"married":false} 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"Alcaoa","birth":1960,"married":false} 
+27.04.(18:35:05) INFO->Q: select count(*) from ex_human 
+10 Human Vertices created
+------------------------------ get a sorted list of married humans ---------------------------------
+
+27.04.(18:35:05) INFO->Q: select name, 2022-birth as age  from  ( select from ex_human where married = true order by birth  )  
+{:name=>"Revelli", :age=>74}
+{:name=>"Fulkerson", :age=>60}
+{:name=>"Sniezek", :age=>50}
+{:name=>"Portwine", :age=>47}
+{:name=>"Jacks", :age=>29}
+------------------------------ and one for not married humans      ---------------------------------
+
+27.04.(18:35:05) INFO->Q: select name, 2022-birth as age  from  ( select from ex_human where married = false order by birth  )  
+{:name=>"Tomasulo", :age=>69}
+{:name=>"Alcaoa", :age=>62}
+{:name=>"Keala", :age=>61}
+{:name=>"Guthorn", :age=>60}
+{:name=>"Gorby", :age=>43}
+------------------------------ connect  married humans  with children ------------------------------
+27.04.(18:35:05) INFO->Q: select from ex_human where married = false order by birth
+27.04.(18:35:05) INFO->Q: select from ex_human where married = true order by birth
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #19:0 to #10:0 CONTENT {"set":{}}
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #4:0 to #4:1 CONTENT {"set":{}}
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #7:0 to #16:0 CONTENT {"set":{}}
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #13:0 to #1:0 CONTENT {"set":{}}
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #22:0 to #1:1 CONTENT {"set":{}}
+--------------------------- Parent and Children ---------------------------------------------------
+
+      Parent      Age      Child                sorted by Child 
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+27.04.(18:35:05) INFO->Q: select in() from ex_human where married = false order by name
+27.04.(18:35:05) INFO->Q: select out() from #4:0 
+Fulkerson       60     Alcaoa  
+27.04.(18:35:05) INFO->Q: select out() from #22:0 
+Jacks       29      Gorby  
+27.04.(18:35:05) INFO->Q: select out() from #13:0 
+Portwine       47    Guthorn  
+27.04.(18:35:05) INFO->Q: select out() from #7:0 
+Sniezek       50      Keala  
+27.04.(18:35:05) INFO->Q: select out() from #19:0 
+Revelli       74   Tomasulo  
+--------------------------- child and parent  -----------------------------------------------------
+
+  Child      Age     Parent               sorted by Parent 
+- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
+27.04.(18:35:05) INFO->Q: select out() from ex_human where married = true order by name
+27.04.(18:35:05) INFO->Q: select in() from #4:1 
+Alcaoa       62  Fulkerson  
+27.04.(18:35:05) INFO->Q: select in() from #1:1 
+Gorby       43      Jacks  
+27.04.(18:35:05) INFO->Q: select in() from #1:0 
+Guthorn       60   Portwine  
+27.04.(18:35:05) INFO->Q: select in() from #10:0 
+Tomasulo       69    Revelli  
+27.04.(18:35:05) INFO->Q: select in() from #16:0 
+Keala       61    Sniezek  
+--------------------------- Add  child to a parent  -----------------------------------------------
+
+27.04.(18:35:05) INFO->Q: select in() from ex_human where married = false 
+27.04.(18:35:05) INFO->Q: INSERT INTO ex_human CONTENT {"name":"TestBaby","birth":2022,"married":false} 
+27.04.(18:35:05) INFO->Q: create edge ex_depend_on from #13:0 to #7:1 CONTENT {"set":{}}
+27.04.(18:35:05) INFO->Q: select in() from ex_human where married = false 
+Parent: <ex_human[#13:0]: {0->}{->2}}, birth: 1975, married: true, name: Portwine>
+27.04.(18:35:05) INFO->Q: select in() from ex_human where married = false 
+27.04.(18:35:05) INFO->Q: select out() from #13:0 
+Children: 
+ <ex_human[#1:0]: {->}{->}}, birth: 1962, married: false, name: Guthorn>
+ <ex_human[#7:1]: {->}{->}}, birth: 2022, married: false, name: TestBaby>
+
+

data/lib/arcade/api/operations.rb

@@ -0,0 +1,306 @@
+module Arcade
+ module  Api
+=begin
+  This is a simple admin interface
+
+  $ Arcade::Api.databases                   # returns an Array of known databases
+  $ Arcade::Api.create_database <a string>  # returns true if succesfull
+  $ Arcade::Api.drop_database   <a string>  # returns true if successfull
+
+  $ Arcade::Api.create_document <database>, <type>,  attributes
+  $ Arcade::Api.execute( <database> ) { <query> }
+  $ Arcade::Api.query( <database> ) { <query> }
+  $ Arcade::Api.get_record <database>,  rid  #  returns a hash
+
+
+  <query> is  either a  string
+          or a hash   { :query => " ",
+                        :language => one of :sql, :cypher, :gmelion: :neo4j ,
+                        :params =>   a  hash of parameters,
+                        :limit => a number ,
+                        :serializer:  one of :graph, :record }
+
+=end
+
+
+    def self.databases
+      get_data 'databases'
+    end
+
+    def self.create_database name
+      unless databases.include?( name.to_s )
+      payload = { "command" => "create database #{name}" }.to_json
+        post_data  "server", { body: payload }.merge( auth ).merge( json )
+      end
+    rescue QueryError => e
+      logger.fatal "Create database #{name} through \"POST create/#{name}\" failed"
+      logger.fatal  e
+      raise
+    end
+
+    def self.drop_database name
+      if databases.include?( name.to_s )
+      payload = { "command" => "drop database #{name}" }.to_json
+        post_data  "server", { body: payload }.merge( auth ).merge( json )
+      end
+    end
+    # ------------------------------  create document ------------------------------------------------- #
+    # adds a document to the database
+    #
+    # specify database-fields as hash-type parameters
+    #
+    # i.e   Arcade::Api.create_document 'devel', 'documents',  name: 'herta meyer', age: 56, sex: 'f'
+    #
+    # returns the rid of the inserted dataset
+    # 
+    def self.create_document database, type, **attributes
+      payload = { "@type" => type }.merge( attributes ).to_json
+      logger.debug "C: #{payload}"
+      options = if session.nil?
+                  { body: payload }.merge( auth ).merge( json )
+                else
+        { body: payload }.merge( auth ).merge( json ).merge( headers: { "arcadedb-session-id" => session })
+                end
+      post_data "document/#{database}", options
+    end
+
+    # ------------------------------  execute         ------------------------------------------------- #
+    # executes a sql-query in the specified database
+    #
+    # the  query is provided as block
+    #
+    # returns an Array of results (if propriate)
+    # i.e
+    # Arcade::Api.execcute( "devel" ) { 'select from test  ' }
+    #  =y [{"@rid"=>"#57:0", "@type"=>"test", "name"=>"Hugo"}, {"@rid"=>"#60:0", "@type"=>"test", "name"=>"Hubert"}]
+    #
+    def self.execute database, query=nil
+      pl = query.nil? ? provide_payload(yield) : provide_payload(query)
+      options =   { body: pl }.merge( auth ).merge( json )
+      unless session.nil?
+        options = options.merge( headers: { "arcadedb-session-id" => session })
+      end
+      post_data "command/#{database}" , options
+    rescue Arcade::QueryError => e
+#        puts e.methods
+        #puts e.exception
+       # puts e.full_message
+        if   e.message =~ /retry/
+          retry
+        else
+          raise   e.message
+        end
+    end
+
+    # ------------------------------  query           ------------------------------------------------- #
+    # same for idempotent queries
+    def self.query database, query
+      options = { body: provide_payload(query)  }.merge( auth ).merge( json )
+      post_data   "query/#{database}" , options
+    end
+
+    # ------------------------------  get_record      ------------------------------------------------- #
+    # fetches a record by providing  database and  rid
+    # and returns the result as hash
+    #
+    # > Api.get_record 'devel', '225:6'
+    # > Api.get_record 'devel', 225, 6
+    # > Api.get_record 'devel', '#225:6'
+    #     => {:@out=>0, :@rid=>"#225:6", :@in=>0, :@type=>"my_names", :name=>"Zaber", :@cat=>"v"}
+
+    def self.get_record database, *rid
+      rid =  rid.join(':')
+      rid = rid[1..-1] if rid[0]=="#"
+      if rid.rid?
+      get_data  "document/#{database}/#{rid}"
+      else
+        raise Arcade::Error "Get requires a rid input"
+      end
+    end
+
+    # ------------------------------  property        ------------------------------------------------- #
+    # Adds properties to the type
+    #
+    #  call via
+    #  Api.property <database>, <type>, name1: a_format , name2: a_format
+    #
+    #  Format is one of
+    #   Boolean, Integer, Short, Long, Float, Double, String
+    #   Datetime, Binary, Byte, Decimal, Link
+    #   Embedded, EmbeddedList, EmbeddedMap
+    #
+    #   In case of an Error,  anything is rolled back and nil is returned
+    #
+    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
+      else
+        rollback database
+      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?
+  #    puts " create index  #{type.to_s}[#{name.to_s}] on #{type} ( #{properties.join(',')} ) #{unique_requested}" 
+      #    VV 22.10: providing an index-name raises an  Error (  Encountered " "(" "( "" at line 1, column 44. Was expecting one of:     <EOF>      <SCHEMA> ...     <NULL_STRATEGY> ...     ";" ...     "," ...   )) )
+      #    named  indices droped for now
+      success = execute(database) {" create index   on #{type} ( #{properties.join(',')} ) #{unique_requested}" } &.first
+#      puts "success: #{success}"
+      success && success.keys == [ :totalIndexed, :name, :operation ] &&   success[:operation] == 'create index' 
+
+    end
+
+
+    # ------------------------------ transaction      ------------------------------------------------- #
+    #
+    def self.begin_transaction database
+      result  = Typhoeus.post Arcade::Config.base_uri + "begin/#{database}", auth
+      @session_id = result.headers["arcadedb-session-id"]
+
+      # returns the session-id 
+    end
+
+
+    # ------------------------------ commit           ------------------------------------------------- #
+    def self.commit database
+    options =  auth.merge( headers: { "arcadedb-session-id" => session })
+      post_data  "commit/#{database}", options
+      @session_id =  nil
+    end
+
+    # ------------------------------ rollback         ------------------------------------------------- #
+    def  self.rollback database, publish_error=true
+      options =  auth.merge( headers: { "arcadedb-session-id" => session })
+      post_data  "rollback/#{database}", options
+      @session_id =  nil
+      raise Arcade::RollbackError "A Transaction has been rolled back"   if publish_error
+    end
+
+    private
+
+     def self.logger
+       Database.logger
+     end
+
+    def self.session
+      @session_id
+    end
+
+    def self. provide_payload( the_yield, action: :post )
+      unless the_yield.is_a? Hash
+        logger.info "Q: #{the_yield}"
+        the_yield =  { :query => the_yield }
+      end
+      { language: 'sql' }.merge( 
+                                the_yield.map do | key,  value |
+                                  case key
+                                  when :query
+                                   action == :post ? [ :command, value ] : [ :query, value ]
+                                  when :limit
+                                    [ :limit , value ]
+                                  when :params
+                                    if value.is_a? Hash
+                                      [ :params, value ]
+                                    end
+                                    # serializer (optional) specify the serializer used for the result:
+                                    #  graph: returns as a graph separating vertices from edges
+                                    #  record: returns everything as records
+                                    # by default it’s like record but with additional metadata for vertex records,
+                                    # such as the number of outgoing edges in @out property and total incoming edges 
+                                    # in @in property. This serialzier is used by Studio
+                                  when :serializer
+                                    if [:graph, :record].include? value.to_sym
+                                      [ :serializer, value.to_sym ]
+                                    end
+                                  when :language
+                                    if [:sql, :cypher, :gremlin, :neo4j ].include? value.to_sym
+                                      [ :language,  value.to_sym ]
+                                    end
+                                  end # case
+                                end .to_h ).to_json # map
+    end
+
+    def self.get_data command, options = auth
+      result  = Typhoeus.get Arcade::Config.base_uri + command, options
+      analyse_result(result, command)
+    end
+
+
+    def self.post_data command, options = auth
+   #   puts "Post DATA #{command} #{options}"   # debug
+      i = 0; a=""
+      loop do
+        result  = Typhoeus.post Arcade::Config.base_uri + command, options
+        #  Code: 503 – Service Unavailable
+        if result.response_code.to_i == 503  #  retry two times
+          i += 1
+          raise Arcade::QueryError, JSON.parse( result.response_body, symbolize_names: true )[:result] if i > 3
+          sleep 0.1
+        else
+         a= analyse_result(result, command )
+          break
+        end
+      end
+      a
+    end
+
+    # returns the json-response
+    def self.analyse_result r, command
+      if r.success?
+          return nil  if r.response_code == 204  # no content
+          result = JSON.parse( r.response_body, symbolize_names: true )[:result]
+          if result == [{}]
+           []
+          else
+            result
+          end
+        elsif r.timed_out?
+          raise Arcade::Error "Timeout Error", caller
+          []
+        elsif r.response_code > 0
+          logger.error  "Execution Failure – Code: #{ r.response_code } – #{r.status_message} "
+          error_message = JSON.parse( r.response_body, symbolize_names: true )
+          logger.error  "ErrorMessage:  #{ error_message[:detail]} "
+          if error_message[:detail] =~ /Duplicated key/
+            raise Arcade::IndexError, error_message[:detail]
+          else
+          # available fields:  :detail, :exception, error
+            puts  error_message[:detail]
+            #raise  error_message[:detail], caller
+          end
+        end
+    end
+    def self.auth
+       @a ||= { httpauth: :basic,
+         username: Arcade::Config.admin[:user],
+         password: Arcade::Config.admin[:pass] }
+    end
+
+    def self.json
+      { headers: { "Content-Type" => "application/json"} }
+    end
+#  not tested
+    def self.delete_data command
+      result  = Typhoeus.delete Arcade::Config.base_uri + command, auth
+      analyse_result(result, command)
+    end
+  end
+end

data/lib/arcade/api/version.rb

@@ -0,0 +1,5 @@
+module Arcade
+  module Api
+    VERSION = 0.1
+  end
+end