activecypher 0.13.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c24fcfa519e4e44a2e8c8d1e84ae0b975d0d73d25492b025f4968e148a2090
-  data.tar.gz: f9ef843ec7859048e7284731122be13ec519f9d44066471db70db1d4d326198f
+  metadata.gz: bfba386d94660c96cf6078ac0a7d370d2dd5670e9316a3de2ee917f409f227ab
+  data.tar.gz: e2e70d29dc99279b51f810363d50749e470556481e80c8c8276fc80ba612b7d4
 SHA512:
-  metadata.gz: 0afa400aeab7bfc05a7842cf4361f064b052ec52c8d2fc402da767da882277e8ad1b2c14a2b3c6396c3d34cc436caa45cb43978727d4cd02da80e589af197b10
-  data.tar.gz: e76af4465bdfb80f6b388137e849b2b2705e1f9fd8ae5afd81369f19d40c144819cc5eba6f106677a37932b7a0bbab864951fef2e5fb2450aca982e81971065b
+  metadata.gz: 1fbe83583d2cdb4a7ea898e8ce5876cfd6907af332ffd7b77643473026ac5fd0d3714bcf037876d2c8ebd8722594a9e5635ae0b3c816c4a98ed9f49dad99e523
+  data.tar.gz: bc13b5392ce91d0247bd4166310e8967676763b9d11f3156206f7a8e3b004f3158b5341dfbadfec82677fc887ef6aedfc8fe51081ea722d847cce60eb155f1d0

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -88,10 +88,18 @@ module ActiveCypher
           run_response = connection.read_message
           unless run_response.is_a?(Bolt::Messaging::Success)
             # Read any remaining messages to clear connection state
-            connection.read_message rescue nil
+            begin
+              connection.read_message
+            rescue StandardError
+              nil
+            end
             # Send RESET to clear connection state
             connection.write_message(Bolt::Messaging::Reset.new)
-            connection.read_message rescue nil
+            begin
+              connection.read_message
+            rescue StandardError
+              nil
+            end
             raise QueryError, "DDL failed for: #{cypher.inspect}\nError: #{run_response.fields.first}"
           end
 
@@ -100,22 +108,71 @@ module ActiveCypher
         end
       end
 
-      # Override run to execute queries without explicit transactions
-      # Memgraph auto‑commits each query, so we send RUN + PULL directly
+      # Override run to execute queries using auto-commit mode.
+      # Memgraph auto-commits each query, so we send RUN + PULL directly
+      # without BEGIN/COMMIT wrapper. This avoids transaction state issues.
       def run(cypher, params = {}, context: 'Query', db: nil, access_mode: :write)
         connect
         logger.debug { "[#{context}] #{cypher} #{params.inspect}" }
 
         instrument_query(cypher, params, context: context, metadata: { db: db, access_mode: access_mode }) do
-          session = Bolt::Session.new(connection)
+          run_auto_commit(cypher, prepare_params(params))
+        end
+      end
 
-          rows = session.run_transaction(access_mode, db: db) do |tx|
-            result = tx.run(cypher, prepare_params(params))
-            result.respond_to?(:to_a) ? result.to_a : result
-          end
+      # Execute a query in auto-commit mode (no explicit transaction).
+      # Sends RUN + PULL directly to the connection.
+      #
+      # @param cypher [String] The Cypher query
+      # @param params [Hash] Query parameters
+      # @return [Array<Hash>] The result rows
+      def run_auto_commit(cypher, params = {})
+        Sync do
+          # Send RUN message
+          run_meta = {}
+          connection.write_message(Bolt::Messaging::Run.new(cypher, params, run_meta))
 
-          session.close
-          rows
+          # Read RUN response
+          run_response = connection.read_message
+
+          case run_response
+          when Bolt::Messaging::Success
+            # Send PULL to get results
+            connection.write_message(Bolt::Messaging::Pull.new({ n: -1 }))
+
+            # Collect records
+            rows = []
+            fields = run_response.metadata['fields'] || []
+
+            loop do
+              msg = connection.read_message
+              case msg
+              when Bolt::Messaging::Record
+                # Convert record values to hash with field names
+                row = fields.zip(msg.values).to_h
+                rows << row
+              when Bolt::Messaging::Success
+                # End of results
+                break
+              when Bolt::Messaging::Failure
+                code = msg.metadata['code']
+                message = msg.metadata['message']
+                connection.reset!
+                raise QueryError, "Query failed: #{code} - #{message}"
+              else
+                raise ProtocolError, "Unexpected response during PULL: #{msg.class}"
+              end
+            end
+
+            rows
+          when Bolt::Messaging::Failure
+            code = run_response.metadata['code']
+            message = run_response.metadata['message']
+            connection.reset!
+            raise QueryError, "Query failed: #{code} - #{message}"
+          else
+            raise ProtocolError, "Unexpected response to RUN: #{run_response.class}"
+          end
         end
       end
 
@@ -213,8 +270,13 @@ module ActiveCypher
 
       def protocol_handler_class = ProtocolHandler
 
+      # Memgraph 3.7+ is expected. Earlier versions are untested and may not work.
+      # See: https://memgraph.com/docs for version-specific features.
+      MINIMUM_VERSION = '3.7'
+
       def validate_connection
-        raise ActiveCypher::ConnectionError, "Server at #{config[:uri]} is not Memgraph" unless connection.server_agent.to_s.include?('Memgraph')
+        agent = connection.server_agent.to_s
+        raise ActiveCypher::ConnectionError, "Server at #{config[:uri]} is not Memgraph" unless agent.include?('Memgraph')
 
         true
       end

data/lib/active_cypher/migration.rb

@@ -28,10 +28,26 @@ module ActiveCypher
 
     # DSL ---------------------------------------------------------------
 
-    def create_node_index(label, *props, unique: false, if_not_exists: true, name: nil)
+    # Create a node property index.
+    # @param label [Symbol, String] Node label
+    # @param props [Array<Symbol>] Properties to index
+    # @param unique [Boolean] Create unique index (Neo4j only)
+    # @param if_not_exists [Boolean] Add IF NOT EXISTS clause (Neo4j only)
+    # @param name [String] Index name (Neo4j only)
+    # @param composite [Boolean] Create composite index (Memgraph 3.2+). Default true for multiple props.
+    def create_node_index(label, *props, unique: false, if_not_exists: true, name: nil, composite: nil)
+      # Default composite to true when multiple properties provided
+      composite = props.size > 1 if composite.nil?
+
       cypher = if connection.vendor == :memgraph
-                 # Memgraph syntax: CREATE INDEX ON :Label(prop)
-                 props.map { |p| "CREATE INDEX ON :#{label}(#{p})" }
+                 if composite && props.size > 1
+                   # Memgraph 3.2+ composite index: CREATE INDEX ON :Label(prop1, prop2)
+                   props_list = props.join(', ')
+                   ["CREATE INDEX ON :#{label}(#{props_list})"]
+                 else
+                   # Memgraph single property indexes
+                   props.map { |p| "CREATE INDEX ON :#{label}(#{p})" }
+                 end
                else
                  # Neo4j syntax
                  props_clause = props.map { |p| "n.#{p}" }.join(', ')
@@ -46,10 +62,23 @@ module ActiveCypher
       operations.concat(Array(cypher))
     end
 
-    def create_rel_index(rel_type, *props, if_not_exists: true, name: nil)
+    # Create a relationship property index.
+    # @param rel_type [Symbol, String] Relationship type
+    # @param props [Array<Symbol>] Properties to index
+    # @param if_not_exists [Boolean] Add IF NOT EXISTS clause (Neo4j only)
+    # @param name [String] Index name (Neo4j only)
+    # @param composite [Boolean] Create composite index (Memgraph 3.2+). Default true for multiple props.
+    def create_rel_index(rel_type, *props, if_not_exists: true, name: nil, composite: nil)
+      composite = props.size > 1 if composite.nil?
+
       cypher = if connection.vendor == :memgraph
-                 # Memgraph syntax: CREATE EDGE INDEX ON :REL_TYPE(prop)
-                 props.map { |p| "CREATE EDGE INDEX ON :#{rel_type}(#{p})" }
+                 if composite && props.size > 1
+                   # Memgraph 3.2+ composite edge index
+                   props_list = props.join(', ')
+                   ["CREATE EDGE INDEX ON :#{rel_type}(#{props_list})"]
+                 else
+                   props.map { |p| "CREATE EDGE INDEX ON :#{rel_type}(#{p})" }
+                 end
                else
                  # Neo4j syntax
                  props_clause = props.map { |p| "r.#{p}" }.join(', ')
@@ -99,6 +128,94 @@ module ActiveCypher
       operations.concat(Array(cypher))
     end
 
+    # Create a vector index (Memgraph 3.4+, Neo4j 5.0+).
+    # @param name [String] Index name
+    # @param label [Symbol, String] Node label
+    # @param property [Symbol] Property containing vector embeddings
+    # @param dimension [Integer] Vector dimension (required)
+    # @param metric [Symbol] Distance metric: :cosine, :euclidean, :dot_product (default: :cosine)
+    # @param quantization [Symbol] Quantization type for memory reduction (Memgraph 3.4+): :scalar, nil
+    def create_vector_index(name, label, property, dimension:, metric: :cosine, quantization: nil)
+      cypher = if connection.vendor == :memgraph
+                 config = { dimension: dimension, metric: metric.to_s }
+                 config[:scalar_kind] = 'f32' if quantization == :scalar
+                 config_str = config.map { |k, v| "#{k}: #{v.is_a?(String) ? "'#{v}'" : v}" }.join(', ')
+                 "CREATE VECTOR INDEX #{name} ON :#{label}(#{property}) WITH CONFIG { #{config_str} }"
+               else
+                 # Neo4j syntax
+                 options = { indexConfig: { 'vector.dimensions' => dimension, 'vector.similarity_function' => metric.to_s.upcase } }
+                 opts_str = options.to_json.gsub('"', "'")
+                 "CREATE VECTOR INDEX #{name} IF NOT EXISTS FOR (n:#{label}) ON (n.#{property}) OPTIONS #{opts_str}"
+               end
+      operations << cypher
+    end
+
+    # Create a vector index on relationships (Memgraph 3.4+, Neo4j 2025+).
+    # @param name [String] Index name
+    # @param rel_type [Symbol, String] Relationship type
+    # @param property [Symbol] Property containing vector embeddings
+    # @param dimension [Integer] Vector dimension (required)
+    # @param metric [Symbol] Distance metric: :cosine, :euclidean, :dot_product (default: :cosine)
+    def create_vector_rel_index(name, rel_type, property, dimension:, metric: :cosine)
+      cypher = if connection.vendor == :memgraph
+                 config_str = "dimension: #{dimension}, metric: '#{metric}'"
+                 "CREATE VECTOR EDGE INDEX #{name} ON :#{rel_type}(#{property}) WITH CONFIG { #{config_str} }"
+               else
+                 # Neo4j 2025+ syntax
+                 "CREATE VECTOR INDEX #{name} IF NOT EXISTS FOR ()-[r:#{rel_type}]-() ON (r.#{property}) " \
+                   "OPTIONS { indexConfig: { `vector.dimensions`: #{dimension}, `vector.similarity_function`: '#{metric}' } }"
+               end
+      operations << cypher
+    end
+
+    # Alias for backwards compatibility
+    alias create_vector_edge_index create_vector_rel_index
+
+    # Create a text index on edges (Memgraph 3.6+ only).
+    # Neo4j fulltext indexes on relationships use different syntax via create_fulltext_rel_index.
+    # @param name [String] Index name
+    # @param rel_type [Symbol, String] Relationship type
+    # @param props [Array<Symbol>] Properties to index
+    def create_text_edge_index(name, rel_type, *props)
+      raise NotImplementedError, 'Text edge indexes only supported on Memgraph 3.6+' unless connection.vendor == :memgraph
+
+      props.each do |p|
+        index_name = props.size > 1 ? "#{name}_#{p}" : name.to_s
+        operations << "CREATE TEXT EDGE INDEX #{index_name} ON :#{rel_type}(#{p})"
+      end
+    end
+
+    # Create a fulltext index on relationships (Neo4j only).
+    # @param name [String] Index name
+    # @param rel_type [Symbol, String] Relationship type
+    # @param props [Array<Symbol>] Properties to index
+    # @param if_not_exists [Boolean] Add IF NOT EXISTS clause
+    def create_fulltext_rel_index(name, rel_type, *props, if_not_exists: true)
+      raise NotImplementedError, 'Fulltext relationship indexes only supported on Neo4j' unless connection.vendor == :neo4j
+
+      props_clause = props.map { |p| "r.#{p}" }.join(', ')
+      c = +"CREATE FULLTEXT INDEX #{name}"
+      c << ' IF NOT EXISTS' if if_not_exists
+      c << " FOR ()-[r:#{rel_type}]-() ON EACH [#{props_clause}]"
+      operations << c
+    end
+
+    # Drop all indexes (Memgraph 3.6+ only).
+    # Neo4j requires dropping indexes individually.
+    def drop_all_indexes
+      raise NotImplementedError, 'drop_all_indexes only supported on Memgraph 3.6+' unless connection.vendor == :memgraph
+
+      operations << 'DROP ALL INDEXES'
+    end
+
+    # Drop all constraints (Memgraph 3.6+ only).
+    # Neo4j requires dropping constraints individually.
+    def drop_all_constraints
+      raise NotImplementedError, 'drop_all_constraints only supported on Memgraph 3.6+' unless connection.vendor == :memgraph
+
+      operations << 'DROP ALL CONSTRAINTS'
+    end
+
     def execute(cypher_string)
       operations << cypher_string.strip
     end

data/lib/active_cypher/relationship.rb

@@ -59,26 +59,26 @@ module ActiveCypher
     # --------------------------------------------------------------
     # Connection fallback
     # --------------------------------------------------------------
-      # Relationship classes usually share the same Bolt pool as the
-      # node they originate from; delegate there unless the relationship
-      # class was given its own pool explicitly.
-      #
-      #   WorksAtRelationship.connection  # -> PersonNode.connection
-      #
-      def self.connection
-        # If this is a concrete relationship class with from_class defined,
-        # prefer delegating to that node's connection (so role/shard routing is respected).
-        if !abstract_class? && (fc = from_class_name)
-          klass = fc.constantize
-          role  = ActiveCypher::RuntimeRegistry.current_role
-          shard = ActiveCypher::RuntimeRegistry.current_shard
-
-          return klass.connected_to(role: role, shard: shard) do
-            klass.connection
-          end
+    # Relationship classes usually share the same Bolt pool as the
+    # node they originate from; delegate there unless the relationship
+    # class was given its own pool explicitly.
+    #
+    #   WorksAtRelationship.connection  # -> PersonNode.connection
+    #
+    def self.connection
+      # If this is a concrete relationship class with from_class defined,
+      # prefer delegating to that node's connection (so role/shard routing is respected).
+      if !abstract_class? && (fc = from_class_name)
+        klass = fc.constantize
+        role  = ActiveCypher::RuntimeRegistry.current_role
+        shard = ActiveCypher::RuntimeRegistry.current_shard
+
+        return klass.connected_to(role: role, shard: shard) do
+          klass.connection
         end
+      end
 
-        # Otherwise, fall back to node_base_class if present (even if abstract)
+      # Otherwise, fall back to node_base_class if present (even if abstract)
       if (klass = node_base_class)
         return klass.connection
       end
@@ -313,12 +313,10 @@ module ActiveCypher
       end
     rescue ActiveCypher::RecordNotSaved, RuntimeError => e
       # Only catch specific validation errors, let other errors propagate
-      if e.message.include?('must be persisted') || e.message.include?('creation returned no id')
-        log_error "Failed to save #{self.class}: #{e.message}"
-        false
-      else
-        raise
-      end
+      raise unless e.message.include?('must be persisted') || e.message.include?('creation returned no id')
+
+      log_error "Failed to save #{self.class}: #{e.message}"
+      false
     end
 
     # Bang version of save - raises exception if save fails

data/lib/active_cypher/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.13.0'
+  VERSION = '0.14.1'
 
   def self.gem_version
     Gem::Version.new VERSION

data/lib/cyrel/expression/exists.rb

@@ -35,5 +35,38 @@ module Cyrel
         "EXISTS(#{rendered_pattern})"
       end
     end
+
+    # Represents an EXISTS { MATCH ... WHERE ... } subquery predicate (Memgraph 3.5+).
+    # Allows full subquery syntax inside EXISTS block.
+    #
+    # @example
+    #   Cyrel.exists_block { match(Cyrel.node(:a) > Cyrel.rel(:r) > Cyrel.node(:b)); where(Cyrel.prop(:b, :active) == true) }
+    #   # => EXISTS { MATCH (a)-[r]->(b) WHERE b.active = $p1 }
+    class ExistsBlock < Base
+      attr_reader :subquery
+
+      # @param subquery [Cyrel::Query] A query object representing the subquery.
+      def initialize(subquery)
+        raise ArgumentError, 'ExistsBlock requires a Cyrel::Query' unless subquery.is_a?(Cyrel::Query)
+
+        @subquery = subquery
+      end
+
+      # Renders the EXISTS { ... } expression.
+      # @param query [Cyrel::Query] The parent query for parameter merging.
+      # @return [String] The Cypher string fragment.
+      def render(query)
+        inner_cypher, inner_params = @subquery.to_cypher
+
+        # Merge subquery parameters into the parent query
+        # The inner query uses its own parameter keys, we need to register values
+        # which will get new keys in the parent query
+        inner_params.each_value do |value|
+          query.register_parameter(value)
+        end
+
+        "EXISTS { #{inner_cypher} }"
+      end
+    end
   end
 end

data/lib/cyrel/pattern/node.rb

@@ -12,14 +12,16 @@ module Cyrel
 
       attribute :alias_name, Cyrel::Types::SymbolType.new
       attribute :labels,     array: :string, default: []
+      attribute :or_labels,  array: :string, default: []  # Memgraph 3.2+: (n:Label1|Label2)
       attribute :properties, Cyrel::Types::HashType.new, default: -> { {} }
 
       validates :alias_name, presence: true
 
-      def initialize(alias_name, labels: nil, properties: {}, **kw)
+      def initialize(alias_name, labels: nil, or_labels: nil, properties: {}, **kw)
         super(
           { alias_name: alias_name,
             labels: Array(labels).compact.flatten,
+            or_labels: Array(or_labels).compact.flatten,
             properties: properties }.merge(kw)
         )
       end
@@ -38,7 +40,14 @@ module Cyrel
 
       def render(query)
         base = +"(#{alias_name}"
-        base << ':' << labels.join(':') unless labels.empty?
+
+        # OR labels take precedence (Memgraph 3.2+: n:Label1|Label2)
+        if or_labels.any?
+          base << ':' << or_labels.join('|')
+        elsif labels.any?
+          base << ':' << labels.join(':')
+        end
+
         unless properties.empty?
           params = properties.with_indifferent_access
           formatted = params.map do |k, v|
@@ -60,6 +69,7 @@ module Cyrel
       def freeze
         super
         labels.freeze
+        or_labels.freeze
         properties.freeze
       end
 

data/lib/cyrel.rb

@@ -11,8 +11,9 @@ module Cyrel
 
   # Cyrel DSL helper: alias for node creation.
   # Example: Cyrel.n(:person, :Person, name: 'Alice')
-  def n(alias_name = nil, *labels, **properties)
-    Pattern::Node.new(alias_name, labels: labels, properties: properties)
+  # Example: Cyrel.n(:n, or_labels: [:Person, :Organization])  # Memgraph 3.2+
+  def n(alias_name = nil, *labels, or_labels: nil, **properties)
+    Pattern::Node.new(alias_name, labels: labels, or_labels: or_labels, properties: properties)
   end
 
   # Cyrel DSL helper: creates a CALL clause for a procedure.
@@ -29,8 +30,9 @@ module Cyrel
 
   # Cyrel DSL helper: creates a node pattern.
   # Example: Cyrel.node(:n, :Person, name: 'Alice')
-  def node(alias_name = nil, *labels, **properties)
-    Pattern::Node.new(alias_name, labels: labels, properties: properties)
+  # Example: Cyrel.node(:n, or_labels: [:Person, :Organization])  # Memgraph 3.2+
+  def node(alias_name = nil, *labels, or_labels: nil, **properties)
+    Pattern::Node.new(alias_name, labels: labels, or_labels: or_labels, properties: properties)
   end
 
   # Cyrel DSL helper: creates a relationship pattern.
@@ -57,14 +59,14 @@ module Cyrel
       @pending_direction = nil
     end
 
-    def node(alias_name = nil, *labels, **properties)
+    def node(alias_name = nil, *labels, or_labels: nil, **properties)
       # If there's a pending direction, we need to add a relationship first
       if @pending_direction && @elements.any? && @elements.last.is_a?(Cyrel::Pattern::Node)
         @elements << Cyrel::Pattern::Relationship.new(types: [], direction: @pending_direction)
         @pending_direction = nil
       end
 
-      n = Cyrel::Pattern::Node.new(alias_name, labels: labels, properties: properties)
+      n = Cyrel::Pattern::Node.new(alias_name, labels: labels, or_labels: or_labels, properties: properties)
       @elements << n
       self
     end
@@ -250,6 +252,16 @@ module Cyrel
     Expression.exists(pattern)
   end
 
+  # Cyrel DSL helper: creates an EXISTS block with full subquery (Memgraph 3.5+).
+  # Example:
+  #   Cyrel.exists_block { match(Cyrel.node(:a) > Cyrel.rel(:r) > Cyrel.node(:b, :Admin)) }
+  #   # => EXISTS { MATCH (a)-[r]->(b:Admin) }
+  def exists_block(&block)
+    subquery = Query.new
+    subquery.instance_eval(&block)
+    Expression::ExistsBlock.new(subquery)
+  end
+
   # Cyrel DSL helper: creates a Logical NOT expression.
   # Example: Cyrel.not(expression)
   def not(expression)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
 - !ruby/object:Gem::Dependency
   name: io-endpoint
   requirement: !ruby/object:Gem::Requirement