activecypher 0.13.0 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96c24fcfa519e4e44a2e8c8d1e84ae0b975d0d73d25492b025f4968e148a2090
-  data.tar.gz: f9ef843ec7859048e7284731122be13ec519f9d44066471db70db1d4d326198f
+  metadata.gz: 614049312045dc138ca5e6aa6950333aa16936ed7f271c0dde0939971b8a4d9d
+  data.tar.gz: 5fd731b9d85a3b45ceb5a27fb08b86904fd4adebe95aeb928cff7da3a4f556b5
 SHA512:
-  metadata.gz: 0afa400aeab7bfc05a7842cf4361f064b052ec52c8d2fc402da767da882277e8ad1b2c14a2b3c6396c3d34cc436caa45cb43978727d4cd02da80e589af197b10
-  data.tar.gz: e76af4465bdfb80f6b388137e849b2b2705e1f9fd8ae5afd81369f19d40c144819cc5eba6f106677a37932b7a0bbab864951fef2e5fb2450aca982e81971065b
+  metadata.gz: df907144cb86d4ba2bc10e135a71e38979a91faeaa01b1ed231841626c499f19564dbaf327df5445d7338dd7849b09196fafd42155a20e8abe51397d839c3720
+  data.tar.gz: c4879e2edc165ea074510a759878ae99a95d12e6f74b7d4f21a0846bfcf6eedbbfe08c9ba213211ca748dbcde3e7fc2f4d8720857452376edba5c225a90e32c9

data/lib/active_cypher/connection_adapters/memgraph_adapter.rb

@@ -213,8 +213,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/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveCypher
-  VERSION = '0.13.0'
+  VERSION = '0.14.0'
 
   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.0
 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