arcadedb 0.4 → 0.5.2

data/lib/model/vertex.rb

@@ -13,45 +13,46 @@ module Arcade
     end
     ## ----------------------------------------- Class Methods------------------------------------ ##
     #                                                                                               #
+
 =begin
-    Vertex.delete fires a "delete vertex" command to the database.
+   Creates a Vertex-Instance.
+   Similar to `Vertex#insert`.
 
-    To remove all records  use  »all: true« as argument
+   Difference is the presence of a `created` property, a timestamp set to the time and date of creation.
+=end
 
-    To remove a specific rid, use  rid: "#nn:mmm" as argument
+    def self.create timestamp: true, **args
+      #t= timestamp ?  ", created = Date(#{DateTime.now.to_i}) "  : ""
+      t= timestamp ?  ", created = sysdate() "  : ""
+     # db.transmit { "create VERTEX #{database_name} set #{args.map{|x,y| [x,y.to_or].join("=")}.join(', ')+t}" } &.first.allocate_model(false)
+     Api.create_document  db.database, database_name, session_id: db.session,  **args
+    end
 
-    "where" parameter is optional
 
-     ExtraNode.delete where: { item: 67  }  == ExtraNode.delete item: 67
+=begin
+    Vertex.delete fires a "delete vertex" command to the database.
+    To remove all records  use  »all: true« as argument
+    To remove a specific rid, use  rid: "#nn:mmm" as argument
+
+    The "where" parameter is optional
 
+    Example:
+    ExtraNode.delete where: { item: 67   }  == ExtraNode.delete item: 67
 =end
     def self.delete where: {} , **args
       if args[:all] == true
         where = {}
       elsif args[:rid].present?
-        return db.execute { "delete vertex #{args[:rid]}" }.first["count"]
+        return db.transmit { "delete from #{args[:rid]}"  }.first["count"]
       else
         where.merge!(args) if where.is_a?(Hash)
         return 0 if where.empty?
       end
       # query returns [{count => n }]
-      db.execute { "delete vertex #{database_name} #{compose_where(where)}"  } &.first[:count] rescue 0
-    end
-
-=begin
-   Creates a Vertex-Instance.
-   Similar to `Vertex#insert`.
-
-   Difference is the presence of a `created` property, a timestamp set to the time and date of creation.
-=end
-
-    def self.create timestamp: true, **args
-      #t= timestamp ?  ", created = Date(#{DateTime.now.to_i}) "  : ""
-      t= timestamp ?  ", created = sysdate() "  : ""
-      db.execute { "create VERTEX #{database_name} set #{args.map{|x,y| [x,y.to_or].join("=")}.join(', ')+t}" } &.first.allocate_model(false)
+      #  puts "delete from  #{database_name} #{compose_where(where)}"
+      db.transmit { "delete  from `#{database_name}` #{compose_where(where)}"   } &.first[:count] rescue 0
     end
 
-
 ## get adjacent nodes based on a query on the actual model
 
 
@@ -71,22 +72,41 @@ module Arcade
       def expand
         self
       end
-    # Supports where:  -->  Strategie.first nodes  where: {size: 10}
-    # "select  both()[ size = 10  ]  from #113:8 "
+    #  ---------------------------------   Nodes   ----------------------------------------------- #
+      #  fetches adjacet nodes
+      #  supported
+      #  nodes  in_or_out =  :in, :out, :both, :inE, :outE
+      #         depth     =  fetch the n'th node through travese
+      #         via:      =  Arcade Database Type (the ruby class)
+      #         where:    =  a condition
+      #                      inE, outE  -->  matches attributes on the edge
+      #                      in, out, both -> matches attributes on the adjacent vertex
+      #  Example  Strategie.first nodes  where: {size: 10}
+      #  "select  both()[ size = 10  ]  from #113:8 "
+      #
     def nodes in_or_out=:both, depth= 1, via: nil , execute: true, **args
-      s =  Query.new from: rid
-      s.nodes in_or_out, via: via, **args
-      if execute
-         s.query &.select_result
-       else
-         s  #  just return the query
-       end
+      if depth <= 1
+        s= query.nodes in_or_out, via: via, **args
+        execute ? s.query &.select_result : s
+      else
+       travese in_or_out, depth: depth, start_at: depth-1, via: via, execute: execute, where: args[:where]
+      end
     end
 
     # Supports where: { where condition for edges }
-    def edges in_or_out = :both, depth= 1, via: nil , execute: true, **args
-      in_or_out = in_or_out.to_s + "E"
-      nodes in_or_out, depth, via: via , execute: execute, **args
+    def edges in_or_out = :both, depth= 1, via: nil , execute: true
+
+      v = in_or_out.to_s.delete_suffix 'E'
+      e = v + 'E'
+      edge_name = via.nil? ? "" : resolve_edge_name( via )
+      argument =  "#{e}(#{edge_name})"
+      q= if depth > 1
+            repeated_argument = Array.new(depth -1 , "#{v}(#{edge_name})").join(".")
+            query.projection repeated_argument + "." + argument
+         else
+            query.projection  argument
+         end
+      execute ?  q.execute &.allocate_model : q
     end
 
 
@@ -120,17 +140,17 @@ module Arcade
 
     # get via-type-edges  through in
     def inE count=1, via:nil
-      nodes :inE,  count, via: via
+      edges :in,  count, via: via
     end
     #
     # get via-type-edges  through  out
     def outE count=1, via:nil
-      nodes :outE, count,  via: via
+      edges :out, count,  via: via
     end
 
     # get  all via-type-edges
     def bothE  count=1, via:nil
-      nodes :bothE, count, via: via
+      edges :both, count, via: via
     end
 
 
@@ -158,34 +178,33 @@ module Arcade
 			the_query.where where if where.present?
 			the_query.while "$depth < #{depth} " unless depth <=0
 			outer_query = Query.new from: the_query, where: "$depth >= #{start_at}"
-			if execute
-        outer_query.execute.allocate_model
-				else
-		#			the_query.from self  #  complete the query by assigning self
-					the_query            #  returns the Query  -traverse object
-				end
+			execute ?  outer_query.execute.allocate_model :  the_query # return only the traverse part
 		end
 
 =begin
 Assigns another Vertex via an EdgeClass. If specified, puts attributes on the edge.
 
+`Vertex.assign via: Edge to: Vertex`
+
 Returns the reloaded assigned vertex
 
 Wrapper for
-  Edge.create in: self, out: a_vertex,  some: attributes.  on: the,  edge: type }
+  Edge.create from: self, to: a_vertex,  some: attributes.  on: the,  edge: type }
 
 returns the assigned vertex, thus enabling to chain vertices through
 
-    Vertex.assign() via: E , vertex: VertexClass.create()).assign( via: E, ... )
+    Vertex.assign() via: E , to: VertexClass.create()).assign( via: E, ... )
 or
 	  (1..100).each{|n| vertex = vertex.assign(via: E2, vertex: V2.create(item: n))}
 =end
 
-  def assign vertex: , via:   , **attributes
+  def assign vertex: nil , via: Arcade::Edge   , **attributes
+    vertex = attributes[:to] if attributes.has_key? :to
+    raise "vertex not provided" if vertex.nil?
 
     via.create from: self, to: vertex,  **attributes
 
-    db.get vertex.rid  # return the assigned vertex
+    db.get vertex.rid unless vertex.is_a? Array # return the assigned vertex
   rescue IndexError => e
     db.logger.error "Edge not created, already present."
     vertex  #  return the vertex (for chaining)
@@ -194,6 +213,50 @@ or
     nil
   end
 
+=begin
+----------------------------------- Match ------------------------------------------
+(ClassMethod)
+
+Creates a Match-Statement based on the vertex type
+
+```
+m = Watchlist.match( symbol: 'iBit', as: :ibit ) 
+           .out( HasUnderlying)
+           .node( as: :u )
+           
+m.to_s
+  => "MATCH { type: watchlist, where: ( symbol='iBit' ), as: ibit }
+            .out('has_underlying'){ as: u } 
+      RETURN ibit,u "
+```
+=end
+  def self.match **args
+       as = args.delete( :as) || :a
+       args = args.delete( :where ) if args.key?( :where )
+       Arcade::Match.new type: self,  where: args, as: as
+  end
+
+=begin
+----------------------------------- Match ------------------------------------------
+(InstanceMethod)
+
+Creates a Match-Statement based on the current vertex ( i.e  as response to a website-request )
+
+```
+params[:rid] =>  "#49:0"
+
+m= params[:rid].load_rid.match.out( HasUnterlying ).node( as: :u )
+m.to_s
+ => "MATCH { type: strategie, rid: #49:0 }.out('has_underlying'){ as: u } RETURN u "
+```
+=end
+  def match as: nil
+    if as.nil?
+      Arcade::Match.new vertex: self
+    else
+      Arcade::Match.new vertex: self, as: as
+    end
+  end
 
   def remove
     db.execute{ "delete vertex #{rid}" }
@@ -205,12 +268,12 @@ Format: < Classname: Edges, Attributes >
 =end
 	def to_human
 
-    in_and_out = -> { "{#{self.in.count}->}{->#{self.out.count }}, " }
+    in_and_out =  coe.then{| i,o| "{#{i}->}{->#{o}}, "}
 
 		#Default presentation of Arcade::Base::Model-Objects
 
 		"<#{self.class.to_s.snake_case}[#{rid}]:"  +
-      in_and_out[] +
+      in_and_out +
       invariant_attributes.map do |attr, value|
 			v= case value
 				 when  Class
@@ -225,6 +288,13 @@ Format: < Classname: Edges, Attributes >
 	end
 
 
+ # Count Of Edges (coe)
+ # returns an Array: [ count-of-in-edges, count-of-out-edges ]
+   def coe 
+      db.query( "select in().size() as ie, out().size() as oe from #{rid}" ) &.first.values
+   end
+	            
+
     def refresh
       # force reloading of edges and nodes
       # edges are not cached (now)

data/lib/models.rb

@@ -1,6 +1,8 @@
 require_relative "../lib/model/document.rb"
+require_relative "../lib/model/revision_record.rb"
 require_relative "../lib/model/vertex.rb"
 require_relative "../lib/model/edge.rb"
+require_relative "../lib/model/revision.rb"
 require_relative "../lib/model/basicvertex.rb"
 require_relative "../lib/model/basicdocument.rb"
 require_relative "../lib/model/basicedge.rb"

data/lib/types.rb

@@ -0,0 +1,35 @@
+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 )
+
+
+  # Define a type for your DateTime with timezone.  Crucially, use
+# the `.constructor` to handle the string parsing and potential errors. (source: Gemini)
+Types::DateTime = Types::Any.constructor do |value|
+  begin
+    case value
+      when String
+    ::DateTime.parse(value)
+      when Integer
+      ::Time.at(value).to_datetime
+      else
+      ::DateTime.now
+    end
+  rescue ArgumentError
+    # Handle invalid date strings.  Options:
+    # 1. Raise an exception (recommended for API responses)
+    raise Dry::Types::CoercionError.new(
+      value, DateTime, "Invalid DateTime format: #{value}"
+    )
+    # 2. Return nil (less strict, but might lead to unexpected behavior)
+    # nil
+    # 3. Use a default value (be careful with this, as it might mask errors)
+    # DateTime.now
+  end
+end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arcadedb
 version: !ruby/object:Gem::Version
-  version: '0.4'
+  version: 0.5.2
 platform: ruby
 authors:
 - Hartmut Bischoff
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-25 00:00:00.000000000 Z
+date: 2025-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -144,31 +144,37 @@ files:
 - examples/relation_1__1.rb
 - examples/relation_1__n.rb
 - examples/relation_n_n.rb
+- iruby/.ipynb_checkpoints/01-start-and-end-of-datarows-checkpoint.ipynb
+- iruby/01-start-and-end-of-datarows.ipynb
+- iruby/db-console.rb
 - lib/arcade.rb
 - lib/arcade/api/operations.rb
 - lib/arcade/api/primitives.rb
 - lib/arcade/base.rb
+- lib/arcade/config.rb
 - lib/arcade/database.rb
 - lib/arcade/errors.rb
+- lib/arcade/init.rb
 - lib/arcade/logging.rb
+- lib/arcade/match.rb
+- lib/arcade/query.rb
+- lib/arcade/support/class.rb
+- lib/arcade/support/conversions.rb
+- lib/arcade/support/model.rb
+- lib/arcade/support/object.rb
+- lib/arcade/support/sql.rb
+- lib/arcade/support/string.rb
 - lib/arcade/version.rb
-- lib/config.rb
-- lib/init.rb
-- lib/match.rb
 - lib/model/basicdocument.rb
 - lib/model/basicedge.rb
 - lib/model/basicvertex.rb
 - lib/model/document.rb
 - lib/model/edge.rb
+- lib/model/revision.rb
+- lib/model/revision_record.rb
 - lib/model/vertex.rb
 - lib/models.rb
-- lib/query.rb
-- lib/support/class.rb
-- lib/support/conversions.rb
-- lib/support/model.rb
-- lib/support/object.rb
-- lib/support/sql.rb
-- lib/support/string.rb
+- lib/types.rb
 - rails.md
 - rails/arcade.rb
 - rails/config.yml
@@ -177,7 +183,7 @@ homepage: https://github.com/topofocus/arcadedb
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -192,8 +198,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.5.23
+signing_key:
 specification_version: 4
 summary: Ruby Interface to ArcadeDB
 test_files: []

data/lib/match.rb

@@ -1,216 +0,0 @@
-#require 'active_support/inflector'
-
-module Arcade
-	######################## MatchConnection ###############################
-
-	MatchAttributes = Struct.new(:edge, :direction, :as, :count, :where, :while, :max_depth , :depth_alias, :path_alias, :optional )
-
-	# where and while can be composed incremental
-	# direction, as, connect and edge cannot be changed after initialisation
-  class MatchConnection
-    include Support::Sql
-
-    def initialize edge= nil, direction: :both, as: nil, count: 1, **args
-
-      the_edge = edge.is_a?( Class ) ?  edge.ref_name : edge.to_s   unless edge.nil? || edge == E
-			@q =  MatchAttributes.new  the_edge ,  # class
-								direction, #		  may be :both, :in, :out
-								as,				 #      a string
-								count,     #      a number 
-								args[:where],
-								args[:while],
-								args[:max_depth],
-								args[:depth_alias],      # not implemented
-								args[:path_alias],       # not implemented
-								args[:optional]          # not implemented
-    end
-
-    def direction= dir
-      @q[:direction] =  dir
-    end
-
-
-		def direction
-			fillup =  @q[:edge].present? ? @q[:edge] : ''
-			case @q[:direction]
-			when :both
-				".both(#{fillup})"
-			when :in
-				".in(#{fillup})"
-			when :out
-				".out(#{fillup})"
-      when :both_vertex, :bothV
-				".bothV()"
-			when :out_vertex, :outV
-				".outV()"
-			when :in_vertex, :inV
-				".inV()"
-     when :both_edge, :bothE
-			 ".bothE(#{fillup})"
-			when :out_edge, :outE
-				".outE(#{fillup})"
-			when :in_edge, :outE
-				".inE(#{fillup})"
-			end
-
-		end
-
-		def count c=nil
-			if c
-				@q[:count] = c
-			else
-				@q[:count]
-			end
-		end
-
-		def max_depth d=nil
-			if d.nil?
-				@q[:max_depth].present? ? "maxDepth: #{@q[:max_depth] }" : nil
-			else
-				@q[:max_depth] = d
-			end
-		end
-		def edge
-			@q[:edge]
-		end
-
-		def compose
-				where_statement =( where.nil? || where.size <5 ) ? nil : "where: ( #{ generate_sql_list( @q[:where] ) })"
-				while_statement =( while_s.nil? || while_s.size <5) ? nil : "while: ( #{ generate_sql_list( @q[:while] )})"
-
-				ministatement = "{"+ [ as, where_statement, while_statement, max_depth].compact.join(', ') + "}"
-				ministatement = "" if ministatement=="{}"
-
-     (1 .. count).map{|x| direction }.join("") + ministatement
-
-    end
-		alias :to_s :compose
-
-  end  # class
-
-
-	######################## MatchStatement ################################
-
-	MatchSAttributes = Struct.new(:match_class, :as, :where )
-  class MatchStatement
-    include Support
-    def initialize match_class, as: 0,  **args
-			reduce_class = ->(c){ c.is_a?(Class) ? c.ref_name : c.to_s }
-
-			@q =  MatchSAttributes.new( reduce_class[match_class],  # class
-								as.respond_to?(:zero?) && as.zero? ?  reduce_class[match_class].pluralize : as	,
-								args[ :where ])
-
-			@query_stack = [ self ]
-		end
-
-		def match_alias
-			"as: #{@q[:as]}"
-		end
-
-
-
-		# used for the first compose-statement of a compose-query
-		def compose_simple
-				where_statement = where.is_a?(String) && where.size <3 ?  nil :  "where: ( #{ generate_sql_list( @q[:where] ) })"
-			'{'+ [ "class: #{@q[:match_class]}",  as , where_statement].compact.join(', ') + '}'
-		end
-
-
-		def << connection
-			@query_stack << connection
-			self  # return MatchStatement
-		end
-		#
-		def compile &b
-     "match " + @query_stack.map( &:to_s ).join + return_statement( &b )
-		end
-
-
-		# executes the standard-case.
-		# returns
-		#  * as: :hash   : an array of  hashes
-		#  * as: :array  : an array of hash-values
-		#  * as  :flatten: a simple array of hash-values
-		#
-		# The optional block is used to customize the output.
-		# All previously defiend »as«-Statements are provided though the control variable.
-		#
-		# Background
-		# A match query   "Match {class aaa, as: 'aa'} return aa "
-		#
-		# returns [ aa: { result of the query, a Vertex or a value-item  }, aa: {}...}, ...] ]
-		# (The standard case)
-		#
-		# A match query   "Match {class aaa, as: 'aa'} return aa.name "
-		# returns [ aa.name: { name  }, aa.name: { name }., ...] ]
-		#
-		# Now, execute( as: :flatten){ "aa.name" }  returns
-		#  [name1, name2 ,. ...]
-		#
-		#
-		# Return statements  (examples from https://orientdb.org/docs/3.0.x/sql/SQL-Match.html)
-		#  "person.name as name, friendship.since as since, friend.name as friend"
-		#
-		#  " person.name + \" is a friend of \" + friend.name as friends"
-		#
-		#  "$matches"
-		#  "$elements"
-		#  "$paths"
-		#  "$pathElements"
-		#
-		#
-		def execute as: :hash, &b
-			r = V.db.execute{ compile &b }
-			case as
-			when :hash
-				r
-			when :array
-			 r.map{|y| y.values}
-			when :flatten
-			 r.map{|y| y.values}.orient_flatten
-			else
-				raise ArgumentError, "Specify parameter «as:» with :hash, :array, :flatten"
-		 end
-		end
-#		def compose
-#
-#			'{'+ [ "class: #{@q[:match_class]}",
-#					"as: #{@as}" , where, while_s,
-#						@maxdepth >0 ? "maxdepth: #{maxdepth}": nil  ].compact.join(', ')+'}'
-#		end
-
-		alias :to_s :compose_simple
-
-
-##  return_statement
-		#
-		# summarizes defined as-statements ready to be included as last parameter
-		# in the match-statement-stack
-		#
-		# They can be modified through a block.
-		#
-		# i.e
-		#
-		# t= TestQuery.match(  where: {a: 9, b: 's'}, as: nil ) << E.connect("<-", as: :test)
-		# t.return_statement{|y| "#{y.last}.name"}
-		#
-		# =>> " return  test.name"
-		#
-		#return_statement is always called through compile
-		#
-		# t.compile{|y| "#{y.last}.name"}
-
-    private
-		def return_statement
-			resolve_as = ->{ @query_stack.map{|s| s.as.split(':').last unless s.as.nil? }.compact }
-			" return " + statement = if block_given?
-										a= yield resolve_as[]
-										a.is_a?(Array) ? a.join(', ') :  a
-									else
-										resolve_as[].join(', ')
-									end
-		end
-	end  # class
-
-end # module