arcadedb 0.3.1 → 0.4

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,257 @@
+module Arcade
+ module  Api
+   extend Primitives
+=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
+
+    # ------------------------------ Service methods  ------------------------------------------------- #
+    # ------------------------------                  ------------------------------------------------- #
+    # ------------------------------ databases        ------------------------------------------------- #
+    #  returns an array of databases present on the database-server                                     #
+
+    def self.databases
+      get_data 'databases'
+    end
+
+    # ------------------------------ create database  ------------------------------------------------- #
+    #  creates a database if not present                                                                #
+    def self.create_database name
+      return if databases.include?( name.to_s )
+      payload = { "command" => "create database #{name}" }
+        post_data  "server", payload
+    rescue HTTPX::HTTPError => e
+      logger.fatal "Create database #{name} through \"POST create/#{name}\" failed"
+      logger.fatal  e
+      raise
+    end
+
+    # ------------------------------  drop  database  ------------------------------------------------- #
+    #  deletes the given database                                                                       #
+    def self.drop_database name
+      return unless databases.include?( name.to_s )
+      payload = {"command" => "drop database #{name}" }
+       post_data  "server",  payload
+    rescue HTTPX::HTTPError => e
+      logger.fatal "Drop database #{name} through \"POST drop database/#{name}\" failed"
+      raise
+    end
+    # ------------------------------  create document ------------------------------------------------- #
+    # adds a document to the specified database table
+    #
+    # 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 )
+      logger.debug "C: #{payload}"
+      options = if session.nil?
+         payload
+                else
+        payload.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.execute( "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, session_id= nil
+      pl = query.nil? ? provide_payload(yield) : provide_payload(query)
+      if session_id.nil? && session.nil?
+        post_data "command/#{database}" , pl
+      else
+        post_transaction "command/#{database}" , pl, session_id || session
+      end
+    end
+
+    # ------------------------------  query           ------------------------------------------------- #
+    # same for idempotent queries
+    def self.query database, query
+      post_data   "query/#{database}" , provide_payload(query)
+    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 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
+        puts "R: #{r.inspect}"
+        if r.nil?
+          false
+        else
+          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 IF NOT EXISTS on #{type} (#{properties.join(', ')}) #{unique_requested}" } &.first
+#      puts "success: #{success}"
+       success[:operation] == 'create index'
+
+    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 ) # map
+    end
+
+
+
+    # returns the json-response   ## retiered
+    def self.analyse_result r, command
+      if r.success?
+          return nil  if r.status == 204  # no content
+          result = JSON.parse( r.response_body, symbolize_names: true )[:result]
+          if result == [{}]
+           []
+          else
+            result
+          end
+        elsif r.timed_out?
+          raise 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 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: Config.admin[:user],
+         password: Config.admin[:pass] }
+    end
+
+#  not tested
+    def self.delete_data command
+      result  = HTTPX.delete Config.base_uri + command, auth
+      analyse_result(result, command)
+    end
+  end
+end

data/lib/arcade/api/primitives.rb

@@ -0,0 +1,98 @@
+module Arcade
+ module  Api
+   module Primitives
+
+  # This module handles the interaction with the database through HTTPX
+  #
+   # ------------------------------  http ------------------------------------------------------------ #
+   # persistent http handle to the database
+
+    def http
+      break_on = -> (response) { response.status == 500  }
+      @http ||= HTTPX.plugin(:basic_auth).basic_auth(auth[:username], auth[:password])
+                  .plugin(:persistent)
+                  .plugin(:circuit_breaker)
+   #               .plugin(:circuit_breaker, circuit_breaker_break_on: break_on)
+    end
+
+    # ------------------------------  get data -------------------------------------------------------- #
+    def get_data command
+      response = http.get( Config.base_uri + command )
+      response.raise_for_status
+
+      JSON.parse( response.body, symbolize_names: true )[:result]
+      #      alternative to `raise for status `
+#      case response = http.basic_auth(auth[:username], auth[:password]).get( Config.base_uri + command )
+#      in { status: 200..203, body:  }
+#        puts "success: #{JSON.parse(body, symbolize_names: true)[:result]}"
+#      in { status: 400..499, body:  }
+#        puts "client error: #{body.json}"
+#      in { status: 500.., body:  }
+#          puts "server error: #{body.to_s}"
+#      in { error: error  }
+#          puts "error: #{error.message}"
+#      else
+#          raise "unexpected: #{response}"
+#      end
+#      puts "result : #{response}"
+#      puts "code: #{response.status}"
+#      analyse_result(response, command)
+    end
+
+    # ------------------------------ post data -------------------------------------------------------- #
+    def post_data command,  payload
+#      http = HTTPX.plugin(:basic_auth)
+ #                 .basic_auth(auth[:username], auth[:password])
+      response = http.post( Config.base_uri + command, json:  payload )
+      response.raise_for_status
+      JSON.parse( response.body, symbolize_names: true )[:result]
+    end
+
+    # ------------------------------ transaction      ------------------------------------------------- #
+    #
+    def begin_transaction database
+      result  = http.post Config.base_uri + "begin/#{database}"
+      @session_id = result.headers["arcadedb-session-id"]
+      # returns the session-id
+    end
+
+    # ------------------------------ post transaction ------------------------------------------------- #
+    def post_transaction command, params, session_id= @session_id
+     # http = HTTPX.plugin(:basic_auth)
+     #             .basic_auth(auth[:username], auth[:password])
+     #             .with( headers: { "arcadedb-session-id"=>session }, debug_level: 1)
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      response = http_a.post( Config.base_uri + command, json:  params )
+      response.raise_for_status
+      JSON.parse( response.body, symbolize_names: true )[:result]
+
+    end
+
+    # ------------------------------ commit           ------------------------------------------------- #
+    def commit database, session_id = @session_id
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      response = http_a.post( Config.base_uri + "commit/#{database}" )
+      response.raise_for_status
+      @session_id =  nil
+      response.status  #  returns 204 --> success
+                       #          403 --> incalid credentials
+                       #          500 --> Transaction  not begun
+
+    end
+
+    # ------------------------------ rollback         ------------------------------------------------- #
+    def rollback database, session_id = @session_id, publish_error=true
+    #  http = HTTPX.plugin(:basic_auth)
+    #              .basic_auth(auth[:username], auth[:password])
+    #              .with( headers: { "arcadedb-session-id"=>session_id }, debug_level: 1)
+      http_a = http.with(  headers: { "arcadedb-session-id" => session_id } , debug_level: 1)
+      response = http_a.post( Config.base_uri + "rollback/#{database}" )
+      response.raise_for_status
+      @session_id =  nil
+      logger.error  "A Transaction has been rolled back"  # if publish_error
+      response.status
+    end
+  end
+ end
+end
+