activecypher 0.14.0 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 614049312045dc138ca5e6aa6950333aa16936ed7f271c0dde0939971b8a4d9d
-  data.tar.gz: 5fd731b9d85a3b45ceb5a27fb08b86904fd4adebe95aeb928cff7da3a4f556b5
+  metadata.gz: bfba386d94660c96cf6078ac0a7d370d2dd5670e9316a3de2ee917f409f227ab
+  data.tar.gz: e2e70d29dc99279b51f810363d50749e470556481e80c8c8276fc80ba612b7d4
 SHA512:
-  metadata.gz: df907144cb86d4ba2bc10e135a71e38979a91faeaa01b1ed231841626c499f19564dbaf327df5445d7338dd7849b09196fafd42155a20e8abe51397d839c3720
-  data.tar.gz: c4879e2edc165ea074510a759878ae99a95d12e6f74b7d4f21a0846bfcf6eedbbfe08c9ba213211ca748dbcde3e7fc2f4d8720857452376edba5c225a90e32c9
+  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
 

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.14.0'
+  VERSION = '0.14.1'
 
   def self.gem_version
     Gem::Version.new VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activecypher
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.1
 platform: ruby
 authors:
 - Abdelkader Boudih