neo4j-ruby-driver 1.7.4 → 4.4.0.alpha.1

data/ruby/neo4j/driver/query.rb

@@ -0,0 +1,48 @@
+module Neo4j
+  module Driver
+    # The components of a Cypher query, containing the query text and parameter map.
+
+    # @see Session
+    # @see Transaction
+    # @see Result
+    # @see Result#consume()
+    # @see ResultSummary
+    # @since 1.0
+    class Query < Struct.new(:text, :parameters)
+      def initialize(text, **parameters)
+        super(self.class.validated_query_text(text), Values.value!(parameters))
+      end
+
+      # @param newText the new query text
+      # @return a new Query object with updated text
+      def with_text(new_text)
+        new(new_text, parameters)
+      end
+
+      def with_parameters(new_parameters)
+        new(text, new_parameters)
+      end
+
+      # Create a new query with new parameters derived by updating this'
+      # query's parameters using the given updates.
+
+      # Every update key that points to a null value will be removed from
+      # the new query's parameters. All other entries will just replace
+      # any existing parameter in the new query.
+
+      # @param updates describing how to update the parameters
+      # @return a new query with updated parameters
+      def with_updated_parameters(**updates)
+        with_parameters(parameters.merge(updates))
+      end
+
+      private
+
+      def self.validated_query_text(query)
+        Internal::Util::Preconditions.check_argument(query, 'Cypher query text should not be nil')
+        Internal::Util::Preconditions.check_argument(query.present?, 'Cypher query text should not be an empty string')
+        query
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/records.rb

@@ -0,0 +1,13 @@
+module Neo4j
+  module Driver
+    # Static utility methods for retaining records
+
+    # @see Result#list()
+    # @since 1.0
+    class Records
+      def self.column(index, map_function)
+        java.util.function.Function.new.apply{ |record| map_function.apply(record[index]) }
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/session_config.rb

@@ -0,0 +1,15 @@
+module Neo4j
+  module Driver
+    # The session configurations used to configure a session.
+    class SessionConfig < Hash
+      attr_reader :bookmarks, :default_access_mode, :database, :fetch_size, :impersonated_user
+      def initialize(**config)
+        @bookmarks = config.bookmarks
+        @default_access_mode = config.default_access_mode
+        @database = config.database
+        @fetch_size = config.fetch_size
+        @impersonated_user = config.impersonated_user
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/transaction_config.rb

@@ -0,0 +1,46 @@
+module Neo4j
+  module Driver
+    # Configuration object containing settings for transactions.
+    # Instances are immutable and can be reused for multiple transactions.
+    # <p>
+    # Configuration is supported for:
+    # <ul>
+    # <li>queries executed in auto-commit transactions - using various overloads of {@link Session#run(String, TransactionConfig)} and
+    # {@link AsyncSession#runAsync(String, TransactionConfig)}</li>
+    # <li>transactions started by transaction functions - using {@link Session#readTransaction(TransactionWork, TransactionConfig)},
+    # {@link Session#writeTransaction(TransactionWork, TransactionConfig)}, {@link AsyncSession#readTransactionAsync(AsyncTransactionWork, TransactionConfig)} and
+    # {@link AsyncSession#writeTransactionAsync(AsyncTransactionWork, TransactionConfig)}</li>
+    # <li>unmanaged transactions - using {@link Session#beginTransaction(TransactionConfig)} and {@link AsyncSession#beginTransactionAsync(TransactionConfig)}</li>
+    # </ul>
+    # <p>
+    # Creation of configuration objects can be done using the builder API:
+    # <pre>
+    # {@code
+    # Map<String, Object> metadata = new HashMap<>();
+    # metadata.put("type", "update user");
+    # metadata.put("application", "my application");
+    #  TransactionConfig config = TransactionConfig.builder()
+    #                  .withTimeout(Duration.ofSeconds(4))
+    #                  .withMetadata(metadata)
+    #                  .build();
+    #  }
+    #  </pre>
+    # @see Session
+    class TransactionConfig < Hash
+      EMPTY = new
+
+      def initialize(timeout: nil, metadata: {})
+        Internal::Util::Preconditions.check_argument(timeout.nil? || timeout.positive?, 'Transaction timeout should be positive')
+        Internal::Validator.require_non_nil!(metadata)
+        merge(timeout: timeout, metadata: metadata)
+      end
+
+      # Check if this configuration object contains any values.
+
+      # @return {@code true} when no values are configured, {@code false otherwise}.
+      def empty?
+        fetch(:timeout).nil? && fetch(:metadata).blank?
+      end
+    end
+  end
+end

data/ruby/neo4j/driver/values.rb

@@ -0,0 +1,26 @@
+module Neo4j
+  module Driver
+    module Values
+      def self.value!(value)
+        this_method = method(:value!)
+        case value
+        when nil, TrueClass, FalseClass, Integer, Float, String, Symbol, Bookmark, ActiveSupport::Duration,
+          Types::Point, Types::Time, Time, Date
+          value
+        when Hash
+          value.transform_keys!(&this_method).transform_values!(&this_method)
+        when Internal::InternalPath
+          nonconvertible(value)
+        when Enumerable
+          value.map(&this_method)
+        else
+          nonconvertible(value)
+        end
+      end
+
+      def self.nonconvertible(value)
+        raise Exceptions::ClientException, "Unable to convert #{value.class.name} to Neo4j Value."
+      end
+    end
+  end
+end

data/ruby/neo4j/driver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/grouping'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/logger'
+require 'async/io'
+require 'async/io/stream'
+require 'async/pool'
+require 'async/pool/resource'
+require 'async/queue'
+require 'bigdecimal'
+require 'date'
+require 'loader'
+
+Loader.load
+
+module Neo4j
+  module Driver
+    Record = Neo4j::Driver::Internal::InternalRecord
+    Result = Neo4j::Driver::Internal::InternalResult
+    Transaction = Neo4j::Driver::Internal::InternalTransaction
+
+    module Types
+      Entity = Neo4j::Driver::Internal::InternalEntity
+      Node = Neo4j::Driver::Internal::InternalNode
+      Path = Neo4j::Driver::Internal::InternalPath
+      Relationship = Neo4j::Driver::Internal::InternalRelationship
+    end
+  end
+end