arcadedb 0.5.0 → 0.5.4

data/lib/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

@@ -4,22 +4,64 @@ module Arcade
     include Arcade::Support::Sql
 
 =begin
-  This is a very simple wrapper for the match statement
+  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 type: , **args
+=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 = [ "MATCH { type: #{type.database_name}, #{ assigned_parameters } }" ]
+      @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
@@ -49,49 +91,55 @@ module Arcade
     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
+
+    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 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
+    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?
-       "{}"
-              else
-       "{ #{ assigned_parameters } }"
-              end
+       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
 

data/lib/arcade/query.rb

@@ -27,7 +27,8 @@ module Arcade
 								[],   # aliases
 								'',  # database
 								[],   #set,
-								[]  # remove
+								[],  # remove
+							  []   # group by
 			  args.each{|k,v| send k, v}
 				@fill = block_given? ?   yield  : 'and'
 		end
@@ -62,12 +63,10 @@ module Arcade
 			@q[:kind]
 			end
 		end
-=begin
-  Output the compiled query
-  Parameter: destination (rest, batch )
-  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
-=end
-
+    # ------------------ compose---------------------------------------
+    #  Output the compiled query
+    #  Parameter: destination (rest, batch )
+    #  If the query is submitted via the REST-Interface (as get-command), the limit parameter is extracted.
 		def compose(destination: :batch)
 			if kind.to_sym == :update
 				return_statement = "return after " + ( @q[:aliases].empty? ?  "$current" : @q[:aliases].first.to_s)
@@ -126,9 +125,8 @@ module Arcade
 			end
 		end
 
-=begin
-	from can either be a Databaseclass to operate on or a Subquery providing data to query further
-=end
+	# -------------------- from ---------------------------------------
+	#  arg  can either be a Database class to operate on or a Subquery providing data to query further
 		def from arg = nil
 			if arg.present?
 				@q[:database] =  arg
@@ -315,11 +313,8 @@ 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
 
+    # ------------------ nodes ---------------------------------------
 		# adds a connection
 		#  in_or_out:  :out  --->  out('edgeClass')[where-condition]
 		#              :in   --->  in('edgeClass')[where-condition]
@@ -335,7 +330,7 @@ end # class << self
 
 		def nodes in_or_out = :out, via: nil, where: nil, expand:  false
 
-			 condition = where.present? ?  "[ #{generate_sql_list(where)} ]" : ""
+			 condition = where.present? ? "[ #{generate_sql_list(where)} ]" : ""
        via = resolve_edge_name(via) unless via.nil?
 
        argument = if in_or_out.to_s[-1] == 'E'

data/lib/arcade/rag_schema.rb

@@ -0,0 +1,131 @@
+module Arcade
+  ##
+  # Ragschema - A generic class to implement a RAG (Retrieval-Augmented Generation)
+  # compatible database schema for ArcadeDB.
+  #
+  # This module provides a default-index configuration optimized for:
+  # - Vector similarity search (semantic embeddings)
+  # - Metadata filtering
+  #
+  # Usage:
+  #   class MyDocument < Arcade::Vertex
+  #     include Arcade::Ragschema
+  #     attribute :content, Types::String
+  #     attribute :metadata, Types::Hash.optional
+  #   end
+  #
+  #   MyDocument.create_type
+  #
+  module Ragschema
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      ##
+      # Returns the default RAG schema setup commands
+      # to be executed after type creation
+      #
+      # @param vector_dimension [Integer] Dimension of vector embeddings (default: 1536 for OpenAI)
+      # @return [String] SQL commands for index creation
+      def rag_schema(vector_dimension: 1536)
+        type_name = database_name
+        commands = []
+
+        # Vector index for semantic similarity search
+        commands << "CREATE INDEX ON #{type_name} (embedding) LSM_VECTOR METADATA {dimensions: #{vector_dimension}, similarity: 'COSINE'}"
+
+        # Metadata index for filtering
+        commands << "CREATE INDEX IF NOT EXISTS ON #{type_name} (metadata) NOTUNIQUE"
+
+        commands.join("\n")
+      end
+
+      ##
+      # Default db_init method for RAG-compatible models
+      # Override this in your model class to customize
+      #
+      # @return [String] SQL commands to be executed on database
+      def rag_db_init(vector_dimension: 1536)
+        <<~SQL
+          CREATE PROPERTY #{database_name}.embedding ARRAY_OF_FLOATS
+          CREATE PROPERTY #{database_name}.content STRING
+          CREATE PROPERTY #{database_name}.metadata MAP
+          CREATE PROPERTY #{database_name}.source_url STRING
+          CREATE PROPERTY #{database_name}.created_at DATETIME
+          #{rag_schema(vector_dimension: vector_dimension)}
+        SQL
+      end
+
+      ##
+      # Perform vector similarity search across all documents
+      # Returns metadata only (not embedding vectors) for efficiency
+      #
+      # @param query_embedding [Array<Float>] The embedding vector to search for
+      # @param limit [Integer] Maximum number of results (default: 10)
+      # @param threshold [Float] Minimum similarity score (default: 0.7)
+      # @return [Array<Hash>] Matching records with metadata and similarity score
+      def vector_search(query_embedding, limit: 10, threshold: 0.7)
+        raise "vector_search must be called on a model class" unless respond_to?(:database_name)
+
+        type_name = database_name
+        # Convert array to ArcadeDB array literal format: [1.0,2.0,3.0]
+        embedding_array = "[#{query_embedding.join(',')}]"
+
+        # Select metadata fields only (not embedding) for efficiency
+        # Include @rid for reference and all other fields except embedding
+        query = <<~SQL
+          SELECT @rid, title, content, category, tags, author, source_url, created_at, updated_at, distance AS similarity
+          FROM (
+            SELECT expand(vectorNeighbors('#{type_name}[embedding]', #{embedding_array}, #{limit}))
+          )
+          WHERE distance <= (1.0 - #{threshold})
+          ORDER BY distance ASC
+        SQL
+
+        db.query(query)
+      end
+
+      ##
+      # Perform hybrid search combining vector similarity with SQL LIKE filtering
+      # Returns metadata only (not embedding vectors) for efficiency
+      #
+      # @param query_embedding [Array<Float>] The embedding vector
+      # @param text_query [String] SQL LIKE search query
+      # @param limit [Integer] Maximum number of results (default: 10)
+      # @param vector_threshold [Float] Minimum vector similarity (default: 0.7)
+      # @return [Array<Hash>] Matching records with metadata and similarity score
+      def hybrid_search(query_embedding, text_query, limit: 10, vector_threshold: 0.7)
+        raise "hybrid_search must be called on a model class" unless respond_to?(:database_name)
+
+        type_name = database_name
+        # Convert array to ArcadeDB array literal format: [1.0,2.0,3.0]
+        embedding_array = "[#{query_embedding.join(',')}]"
+
+        # Select metadata fields only (not embedding) for efficiency
+        query = <<~SQL
+          SELECT @rid, title, content, category, tags, author, source_url, created_at, updated_at, distance AS similarity
+          FROM (
+            SELECT expand(vectorNeighbors('#{type_name}[embedding]', #{embedding_array}, #{limit}))
+          )
+          WHERE distance <= (1.0 - #{vector_threshold})
+            AND content LIKE '%#{text_query}%'
+          ORDER BY distance ASC
+        SQL
+
+        db.query(query)
+      end
+    end
+
+    ##
+    # Instance method to perform vector similarity search
+    #
+    # @param query_embedding [Array<Float>] The embedding vector to search for
+    # @param limit [Integer] Maximum number of results (default: 10)
+    # @param threshold [Float] Minimum similarity score (default: 0.7)
+    # @return [Array<Base>] Matching records
+    def vector_search(query_embedding, limit: 10, threshold: 0.7)
+      self.class.vector_search(query_embedding, limit: limit, threshold: threshold)
+    end
+  end
+end

data/lib/arcade/support/model.rb

@@ -15,35 +15,31 @@ module Arcade
         end.join(',')
       end
 
-
     #  used by array#allocate_model
       def _allocate_model response=nil, auto = Config.autoload
 
-
       if response.is_a? Hash
         # save rid to a safe place
-        temp_rid = response.delete :"@rid"
-        type     = response.delete :"@type"
-        cat      = response.delete :"@cat"
+        temp_rid = response.delete( :"@rid"  ) || response.delete( :rid ) || "#0:0"
+        type     = response.delete( :"@type" ) || response.delete( :type )  || nil
+        cat      = response.delete( :"@cat"  ) || response.delete( :cat )  || "d"
 
         return response if type.nil?
-        temp_rid = "#0:0" if temp_rid.nil?
-        type = "d" if type.nil?
         # extract type infos  and convert to database-name
         namespace, type_name = type.camelcase_and_namespace
         namespace = self.namespace if namespace.nil?
         # autoconvert rid's in attributes to model-records  (exclude edges!)
         if auto && !(cat.to_s =='e')
-          response.transform_values! do  |x|
+          response.transform_values do  |x|
             case x
             when String
               x.rid? ?  x.load_rid : x                   # follow links
             when Array
               a =[]
-              x.map do| y |
-                # Thread.new do  ## thread or fiber decrease the performance significantly.
+              x.map do | y |
+                # Thread.new do  ## using thread or fiber decreases the performance significantly.
                   if y.is_a?(Hash) && y.include?(:@type)   # if embedded documents are present, load them
-                    y.allocate_model(false)
+                    _allocate_model(y,false)
                   elsif y.rid?                             # if links are present, load the object
                     y.load_rid(false) # do not autoload further records, prevents from recursive locking
                   else
@@ -64,7 +60,18 @@ module Arcade
           end
         end
         # choose the appropriate class
-        klass=  Dry::Core::ClassBuilder.new(  name: type_name, parent: nil, namespace: namespace ).call
+        # First, try to find an existing model class
+        klass = nil
+        begin
+          klass = namespace.const_get(type_name) if namespace && namespace.const_defined?(type_name)
+        rescue NameError
+          # Class not found, will create dynamically
+        end
+        
+        # If no existing class found, create a new one
+        unless klass
+          klass = Dry::Core::ClassBuilder.new( name: type_name, parent: nil, namespace: namespace ).call
+        end
         #
       begin
         # create a new object of that  class with the appropriate attributes
@@ -82,7 +89,7 @@ module Arcade
      elsif response.rid?
        # Autoload rid's
        response.load_rid
-      # auto ? response.load_rid : response
+     #  auto ? response.load_rid : response
      else
        response
       end

data/lib/arcade/support/sql.rb

@@ -44,7 +44,7 @@ If »NULL« should be addressed, { key: nil } is translated to "key = NULL"  (us
           attributes.map do |key, value|
             case value
             when nil
-              "#{key}=NULL"
+              "#{key} is NULL"
             when ::Array
               if value == [nil]
                 "#{key} is NULL"

data/lib/arcade/support/string.rb

@@ -11,9 +11,12 @@ module Arcade
           delimiters = Regexp.union(['-', '_'])
           n,c= self.split(delimiters).then { |first, *rest| [first.tap {|s| s[0] = s[0].upcase}, rest.map(&:capitalize).join]  }
           ## if base is the first part of the type-name, probably Arcade::Base is choosen a namespace. thats wrong
-          namespace_present = unless n == 'Base'
+          # Arcade::Base descendants are prefetched in Init.models
+          # They have to be fetched to  load both  `Arcade::Ge` and `Arcade::GeSomething`
+          #                (otherwise: Arcade::Ge and Arcade::Ge::Something)
+          namespace_present = unless n == 'Base'  ||  Arcade::Init.models.include?(n)
                                 Object.const_get(n)  rescue  false # Database.namespace
-                              else 
+                              else
                                 false
           end
           # if no namespace is found, leave it empty and return the capitalized string as class name
@@ -22,6 +25,10 @@ module Arcade
           [ Database.namespace, self.capitalize ]
         end
       end
+      def camelcase
+      # Split the string into words, capitalize each word, and join them together
+        self.split('_').map(&:capitalize).join
+      end
 
       def snake_case
         n= if split('::').first == Database.namespace.to_s
@@ -51,7 +58,7 @@ module Arcade
       end
 #  return a valid rid (format: "nn:mm") or nil
       def rid
-        self["#"].nil? ? "#"+ self : self if rid? 
+        self["#"].nil? ? "#"+ self : self if rid?
       end
 
       def where **args
@@ -80,7 +87,7 @@ module Arcade
       ## Load the database object if the string is a rid
       # (Default: No Autoloading of rid-links)
       def load_rid autocomplete = false
-        db.get( self ){  autocomplete }  if rid?  rescue nil
+        db.get( self.strip ){  autocomplete }  if rid?  rescue nil
       end
 
       # updates the record    ### retired in favour of Arcade::Base.update
@@ -104,13 +111,3 @@ module Arcade
 end
 
 String.include Arcade::Support::String
-
-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 )
-
-end