moneta 1.1.0 → 1.4.0

data/lib/moneta/adapters/null.rb

@@ -6,8 +6,7 @@ module Moneta
       include Defaults
 
       # @param [Hash] options Options hash
-      def initialize(options = {})
-      end
+      def initialize(options = {}); end
 
       # (see Proxy#key?)
       def key?(key, options = {})

data/lib/moneta/adapters/pstore.rb

@@ -48,7 +48,7 @@ module Moneta
 
       # (see Proxy#store)
       def store(key, value, options = {})
-        transaction {@backend[key] = value }
+        transaction { @backend[key] = value }
       end
 
       # (see Proxy#delete)
@@ -59,7 +59,8 @@ module Moneta
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         transaction do
-          value = Utils.to_int(@backend[key]) + amount
+          existing = @backend[key]
+          value = (existing == nil ? 0 : Integer(existing)) + amount
           @backend[key] = value.to_s
           value
         end

data/lib/moneta/adapters/redis.rb

@@ -26,7 +26,11 @@ module Moneta
       # number as a time to live in seconds.
       def key?(key, options = {})
         with_expiry_update(key, default: nil, **options) do
-          @backend.exists(key)
+          if @backend.respond_to?(:exists?)
+            @backend.exists?(key)
+          else
+            @backend.exists(key)
+          end
         end
       end
 
@@ -100,7 +104,7 @@ module Moneta
       # (see Defaults#values_at)
       def values_at(*keys, **options)
         with_expiry_update(*keys, default: nil, **options) do
-          @backend.mget *keys
+          @backend.mget(*keys)
         end
       end
 
@@ -112,7 +116,7 @@ module Moneta
           old_values = @backend.mget(*keys)
           updates = pairs.each_with_index.with_object({}) do |(pair, i), updates|
             old_value = old_values[i]
-            if !old_value.nil?
+            if old_value != nil
               key, new_value = pair
               updates[key] = yield(key, old_value, new_value)
             end
@@ -146,7 +150,7 @@ module Moneta
 
       def with_expiry_update(*keys, default: @default_expires, **options)
         expires = expires_value(options, default)
-        if expires.nil?
+        if expires == nil
           yield
         else
           future = nil

data/lib/moneta/adapters/restclient.rb

@@ -11,10 +11,19 @@ module Moneta
 
       # @param [Hash] options
       # @option options [String] :url URL
-      # @option options [Faraday connection] :backend Use existing backend instance
+      # @option options [Symbol] :adapter The adapter to tell Faraday to use
+      # @option options [Faraday::Connection] :backend Use existing backend instance
+      # @option options Other options passed to {Faraday::new} (unless
+      #   :backend option is provided).
       def initialize(options = {})
-        raise ArgumentError, 'Option :url is required' unless url = options[:url]
-        @backend = options[:backend] || ::Faraday.new(url: url)
+        @backend = options.delete(:backend) ||
+          begin
+            raise ArgumentError, 'Option :url is required' unless url = options.delete(:url)
+            block = if faraday_adapter = options.delete(:adapter)
+                      proc { |faraday| faraday.adapter faraday_adapter }
+                    end
+            ::Faraday.new(url, options, &block)
+          end
       end
 
       # (see Proxy#key?)

data/lib/moneta/adapters/riak.rb

@@ -30,7 +30,7 @@ module Moneta
       # (see Proxy#load)
       def load(key, options = {})
         @bucket.get(key, options.dup).raw_data
-      rescue ::Riak::FailedRequest => ex
+      rescue ::Riak::FailedRequest
         nil
       end
 
@@ -53,7 +53,7 @@ module Moneta
       # (see Proxy#clear)
       def clear(options = {})
         @bucket.keys do |keys|
-          keys.each{ |key| @bucket.delete(key) }
+          keys.each { |key| @bucket.delete(key) }
         end
         self
       end

data/lib/moneta/adapters/sequel.rb

@@ -7,9 +7,10 @@ module Moneta
     class Sequel
       include Defaults
 
-      # Sequel::UniqueConstraintViolation is defined since sequel 3.44.0
-      # older versions raise a Sequel::DatabaseError.
-      UniqueConstraintViolation = defined?(::Sequel::UniqueConstraintViolation) ? ::Sequel::UniqueConstraintViolation : ::Sequel::DatabaseError
+      autoload :MySQL, 'moneta/adapters/sequel/mysql'
+      autoload :Postgres, 'moneta/adapters/sequel/postgres'
+      autoload :PostgresHStore, 'moneta/adapters/sequel/postgres_hstore'
+      autoload :SQLite, 'moneta/adapters/sequel/sqlite'
 
       supports :create, :increment, :each_key
       attr_reader :backend, :key_column, :value_column
@@ -30,81 +31,58 @@ module Moneta
       #   row of the table in the value_column using the hstore format.  The row to use is
       #   the one where the value_column is equal to the value of this option, and will be created
       #   if it doesn't exist.
+      # @option options [Symbol] :each_key_server Some adapters are unable to do
+      #   multiple operations with a single connection. For these, it is
+      #   possible to specify a separate connection to use for `#each_key`.  Use
+      #   in conjunction with Sequel's `:servers` option
       # @option options All other options passed to `Sequel#connect`
-      def self.new(options = {})
+      def initialize(options = {})
         extensions = options.delete(:extensions)
         connection_validation_timeout = options.delete(:connection_validation_timeout)
         optimize = options.delete(:optimize)
-        backend = options.delete(:backend) ||
-          begin
-            raise ArgumentError, 'Option :db is required' unless db = options.delete(:db)
-            other_cols = [:table, :create_table, :key_column, :value_column, :hstore]
-            ::Sequel.connect(db, options.reject { |k,_| other_cols.member?(k) }).tap do |backend|
-              if extensions
-                raise ArgumentError, 'Option :extensions must be an Array' unless extensions.is_a?(Array)
-                extensions.map(&:to_sym).each(&backend.method(:extension))
-              end
-
-              if connection_validation_timeout
-                backend.pool.connection_validation_timeout = connection_validation_timeout
-              end
-            end
-          end
-
-        instance =
-          if optimize.nil? || optimize
-            case backend.database_type
-            when :mysql
-              MySQL.allocate
-            when :postgres
-              if options[:hstore]
-                PostgresHStore.allocate
-              elsif matches = backend.get(::Sequel[:version].function).match(/PostgreSQL (\d+)\.(\d+)/)
-                # Our optimisations only work on Postgres 9.5+
-                major, minor = matches[1..2].map(&:to_i)
-                Postgres.allocate if major > 9 || (major == 9 && minor >= 5)
-              end
-            when :sqlite
-              SQLite.allocate
-            end
-          end || allocate
+        @backend = options.delete(:backend) ||
+          connect(extensions: extensions, connection_validation_timeout: connection_validation_timeout, **options)
 
-        instance.instance_variable_set(:@backend, backend)
-        instance.send(:initialize, options)
-        instance
-      end
+        if hstore = options.delete(:hstore)
+          @row = hstore.to_s
+          extend Sequel::PostgresHStore
+        elsif optimize == nil || optimize
+          add_optimizations
+        end
 
-      # @api private
-      def initialize(options)
         @table_name = (options.delete(:table) || :moneta).to_sym
         @key_column = options.delete(:key_column) || :k
         @value_column = options.delete(:value_column) || :v
+        @each_key_server = options.delete(:each_key_server)
 
         create_proc = options.delete(:create_table)
-        if create_proc.nil?
+        if create_proc == nil
           create_table
         elsif create_proc
           create_proc.call(@backend)
         end
 
         @table = @backend[@table_name]
+        prepare_statements
       end
 
       # (see Proxy#key?)
       def key?(key, options = {})
-        !@table.where(key_column => key).empty?
+        @key.call(key: key) != nil
       end
 
       # (see Proxy#load)
       def load(key, options = {})
-        @table.where(key_column => key).get(value_column)
+        if row = @load.call(key: key)
+          row[value_column]
+        end
       end
 
       # (see Proxy#store)
       def store(key, value, options = {})
         blob_value = blob(value)
-        unless @table.where(key_column => key).update(value_column => blob_value) == 1
-          @table.insert(key_column => key, value_column => blob_value)
+        unless @store_update.call(key: key, value: blob_value) == 1
+          @create.call(key: key, value: blob_value)
         end
         value
       rescue ::Sequel::DatabaseError
@@ -112,24 +90,27 @@ module Moneta
         (tries += 1) < 10 ? retry : raise
       end
 
-      # (see Proxy#store)
+      # (see Proxy#create)
       def create(key, value, options = {})
-        @table.insert(key_column => key, value_column => blob(value))
+        @create.call(key: key, value: blob(value))
         true
-      rescue UniqueConstraintViolation
+      rescue ::Sequel::ConstraintViolation
         false
       end
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
         @backend.transaction do
-          if existing = @table.where(key_column => key).for_update.get(value_column)
-            amount += Integer(existing)
-            raise IncrementError, "no update" unless @table.
-              where(key_column => key, value_column => existing).
-              update(value_column => blob(amount.to_s)) == 1
+          if existing = @load_for_update.call(key: key)
+            existing_value = existing[value_column]
+            amount += Integer(existing_value)
+            raise IncrementError, "no update" unless @increment_update.call(
+              key: key,
+              value: existing_value,
+              new_value: blob(amount.to_s)
+            ) == 1
           else
-            @table.insert(key_column => key, value_column => blob(amount.to_s))
+            @create.call(key: key, value: blob(amount.to_s))
           end
           amount
         end
@@ -142,7 +123,7 @@ module Moneta
       # (see Proxy#delete)
       def delete(key, options = {})
         value = load(key, options)
-        @table.filter(key_column => key).delete
+        @delete.call(key: key)
         value
       end
 
@@ -160,19 +141,19 @@ module Moneta
 
       # (see Proxy#slice)
       def slice(*keys, **options)
-        @table.filter(key_column => keys).as_hash(key_column, value_column)
+        @slice.all(keys).map! { |row| [row[key_column], row[value_column]] }
       end
 
       # (see Proxy#values_at)
       def values_at(*keys, **options)
-        pairs = slice(*keys, **options)
+        pairs = Hash[slice(*keys, **options)]
         keys.map { |key| pairs[key] }
       end
 
       # (see Proxy#fetch_values)
       def fetch_values(*keys, **options)
         return values_at(*keys, **options) unless block_given?
-        existing = slice(*keys, **options)
+        existing = Hash[slice(*keys, **options)]
         keys.map do |key|
           if existing.key? key
             existing[key]
@@ -185,7 +166,7 @@ module Moneta
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
         @backend.transaction do
-          existing = existing_for_update(pairs)
+          existing = Hash[slice_for_update(pairs)]
           update_pairs, insert_pairs = pairs.partition { |k, _| existing.key?(k) }
           @table.import([key_column, value_column], blob_pairs(insert_pairs))
 
@@ -196,7 +177,7 @@ module Moneta
           end
 
           update_pairs.each do |key, value|
-            @table.filter(key_column => key).update(value_column => blob(value))
+            @store_update.call(key: key, value: blob(value))
           end
         end
 
@@ -206,25 +187,55 @@ module Moneta
       # (see Proxy#each_key)
       def each_key
         return enum_for(:each_key) { @table.count } unless block_given?
-        @table.select(key_column).each do |row|
-          yield row[key_column]
+        if @each_key_server
+          @table.server(@each_key_server).order(key_column).select(key_column).paged_each do |row|
+            yield row[key_column]
+          end
+        else
+          @table.select(key_column).order(key_column).paged_each(stream: false) do |row|
+            yield row[key_column]
+          end
         end
         self
       end
 
       protected
 
-      # See https://github.com/jeremyevans/sequel/issues/715
-      def blob(s)
-        if s == nil
-          nil
-        elsif s.empty?
-          ''
-        else
-          ::Sequel.blob(s)
+      # @api private
+      def connect(db:, extensions: nil, connection_validation_timeout: nil, **options)
+        other_cols = [:table, :create_table, :key_column, :value_column, :hstore]
+        ::Sequel.connect(db, options.reject { |k,| other_cols.member?(k) }).tap do |backend|
+          if extensions
+            raise ArgumentError, 'Option :extensions must be an Array' unless extensions.is_a?(Array)
+            extensions.map(&:to_sym).each(&backend.method(:extension))
+          end
+
+          if connection_validation_timeout
+            backend.pool.connection_validation_timeout = connection_validation_timeout
+          end
+        end
+      end
+
+      # @api private
+      def add_optimizations
+        case backend.database_type
+        when :mysql
+          extend Sequel::MySQL
+        when :postgres
+          if matches = backend.get(::Sequel[:version].function).match(/PostgreSQL (\d+)\.(\d+)/)
+            # Our optimisations only work on Postgres 9.5+
+            major, minor = matches[1..2].map(&:to_i)
+            extend Sequel::Postgres if major > 9 || (major == 9 && minor >= 5)
+          end
+        when :sqlite
+          extend Sequel::SQLite
         end
       end
 
+      def blob(str)
+        ::Sequel.blob(str) unless str == nil
+      end
+
       def blob_pairs(pairs)
         pairs.map do |key, value|
           [key, blob(value)]
@@ -240,286 +251,84 @@ module Moneta
         end
       end
 
-      def existing_for_update(pairs)
-        @table.
-          filter(key_column => pairs.map { |k, _| k }.to_a).
-          for_update.
-          as_hash(key_column, value_column)
+      def slice_for_update(pairs)
+        @slice_for_update.all(pairs.map { |k, _| k }.to_a).map! do |row|
+          [row[key_column], row[value_column]]
+        end
       end
 
       def yield_merge_pairs(pairs)
-        existing = existing_for_update(pairs)
+        existing = Hash[slice_for_update(pairs)]
         pairs.map do |key, new_value|
           new_value = yield(key, existing[key], new_value) if existing.key?(key)
           [key, new_value]
         end
       end
 
-      # @api private
-      class IncrementError < ::Sequel::DatabaseError; end
-
-      # @api private
-      class MySQL < Sequel
-        def store(key, value, options = {})
-          @table.
-            on_duplicate_key_update.
-            insert(key_column => key, value_column => blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          @backend.transaction do
-            # this creates a row-level lock even if there is no existing row (a
-            # "gap lock").
-            if existing = @table.where(key_column => key).for_update.get(value_column)
-              # Integer() will raise an exception if the existing value cannot be parsed
-              amount += Integer(existing)
-              @table.where(key_column => key).update(value_column => amount)
-            else
-              @table.insert(key_column => key, value_column => amount)
-            end
-            amount
-          end
-        rescue ::Sequel::SerializationFailure # Thrown on deadlock
-          tries ||= 0
-          (tries += 1) <= 3 ? retry : raise
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            pairs = yield_merge_pairs(pairs, &block) if block_given?
-            @table.
-              on_duplicate_key_update.
-              import([key_column, value_column], blob_pairs(pairs).to_a)
-          end
-
-          self
-        end
+      def statement_id(id)
+        "moneta_#{@table_name}_#{id}".to_sym
       end
 
-      # @api private
-      class Postgres < Sequel
-        def store(key, value, options = {})
-          @table.
-            insert_conflict(
-              target: key_column,
-              update: {value_column => ::Sequel[:excluded][value_column]}).
-            insert(key_column => key, value_column => blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          update_expr = ::Sequel[:convert_to].function(
-            (::Sequel[:convert_from].function(
-              ::Sequel[@table_name][value_column],
-              'UTF8').cast(Integer) + amount).cast(String),
-            'UTF8')
-
-          if row = @table.
-            returning(value_column).
-            insert_conflict(target: key_column, update: {value_column => update_expr}).
-            insert(key_column => key, value_column => amount.to_s).
-            first
-          then
-            row[value_column].to_i
-          end
-        end
-
-        def delete(key, options = {})
-          if row = @table.returning(value_column).where(key_column => key).delete.first
-            row[value_column]
-          end
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            pairs = yield_merge_pairs(pairs, &block) if block_given?
-            @table.
-              insert_conflict(
-                target: key_column,
-                update: {value_column => ::Sequel[:excluded][value_column]}).
-              import([key_column, value_column], blob_pairs(pairs).to_a)
-          end
-
-          self
-        end
+      def prepare_statements
+        prepare_key
+        prepare_load
+        prepare_store
+        prepare_create
+        prepare_increment
+        prepare_delete
+        prepare_slice
       end
 
-      # @api private
-      class PostgresHStore < Sequel
-        def initialize(options)
-          @row = options.delete(:hstore).to_s
-          @backend.extension :pg_hstore
-          ::Sequel.extension :pg_hstore_ops
-          @backend.extension :pg_array
-          super
-        end
-
-        def key?(key, options = {})
-          !!@table.where(key_column => @row).get(::Sequel[value_column].hstore.key?(key))
-        end
-
-        def store(key, value, options = {})
-          create_row
-          @table.
-            where(key_column => @row).
-            update(value_column => ::Sequel[@table_name][value_column].hstore.merge(key => value))
-          value
-        end
-
-        def load(key, options = {})
-          @table.where(key_column => @row).get(::Sequel[value_column].hstore[key])
-        end
-
-        def delete(key, options = {})
-          value = load(key, options)
-          @table.where(key_column => @row).update(value_column => ::Sequel[value_column].hstore.delete(key))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          create_row
-          pair = ::Sequel[:hstore].function(
-            key,
-            (::Sequel[:coalesce].function(
-              ::Sequel[value_column].hstore[key].cast(Integer),
-              0) + amount).cast(String))
-
-          if row = @table.
-            returning(::Sequel[value_column].hstore[key].as(:value)).
-            where(key_column => @row).
-            update(value_column => ::Sequel.join([value_column, pair])).
-            first
-          then
-            row[:value].to_i
-          end
-        end
-
-        def create(key, value, options = {})
-          create_row
-          1 == @table.
-            where(key_column => @row).
-            exclude(::Sequel[value_column].hstore.key?(key)).
-            update(value_column => ::Sequel[value_column].hstore.merge(key => value))
-        end
-
-        def clear(options = {})
-          @table.where(key_column => @row).update(value_column => '')
-          self
-        end
-
-        def values_at(*keys, **options)
-          @table.
-            where(key_column => @row).
-            get(::Sequel[value_column].hstore[::Sequel.pg_array(keys)]).to_a
-        end
-
-        def slice(*keys, **options)
-          @table.where(key_column => @row).get(::Sequel[value_column].hstore.slice(keys)).to_h
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            create_row
-            pairs = yield_merge_pairs(pairs, &block) if block_given?
-            hash = Hash === pairs ? pairs : Hash[pairs.to_a]
-            @table.
-              where(key_column => @row).
-              update(value_column => ::Sequel[@table_name][value_column].hstore.merge(hash))
-          end
+      def prepare_key
+        @key = @table
+          .where(key_column => :$key).select(1)
+          .prepare(:first, statement_id(:key))
+      end
 
-          self
-        end
+      def prepare_load
+        @load = @table
+          .where(key_column => :$key).select(value_column)
+          .prepare(:first, statement_id(:load))
+      end
 
-        def each_key
-          unless block_given?
-            return enum_for(:each_key) do
-              @backend.from(
-                @table.
-                  where(key_column => @row).
-                  select(::Sequel[@table_name][value_column].hstore.each)).count
-            end
-          end
-          first = false
-          @table.
-            where(key_column => @row).
-            select(::Sequel[@table_name][value_column].hstore.skeys).
-            each do |row|
-              if first
-                first = false
-                next
-              end
-              yield row[:skeys]
-            end
-          self
-        end
+      def prepare_store
+        @store_update = @table
+          .where(key_column => :$key)
+          .prepare(:update, statement_id(:store_update), value_column => :$value)
+      end
 
-        protected
+      def prepare_create
+        @create = @table
+          .prepare(:insert, statement_id(:create), key_column => :$key, value_column => :$value)
+      end
 
-        def create_row
-          @table.
-            insert_ignore.
-            insert(key_column => @row, value_column => '')
-        end
+      def prepare_increment
+        @load_for_update = @table
+          .where(key_column => :$key).for_update
+          .select(value_column)
+          .prepare(:first, statement_id(:load_for_update))
+        @increment_update ||= @table
+          .where(key_column => :$key, value_column => :$value)
+          .prepare(:update, statement_id(:increment_update), value_column => :$new_value)
+      end
 
-        def create_table
-          key_column = self.key_column
-          value_column = self.value_column
+      def prepare_delete
+        @delete = @table.where(key_column => :$key)
+          .prepare(:delete, statement_id(:delete))
+      end
 
-          @backend.create_table?(@table_name) do
-            column key_column, String, null: false, primary_key: true
-            column value_column, :hstore
-            index value_column, type: :gin
-          end
+      def prepare_slice
+        @slice_for_update = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
+          ds.filter(key_column => pl.arg).select(key_column, value_column).for_update
         end
 
-        def existing_for_update(pairs)
-          @table.where(key_column => @row).for_update.
-            get(::Sequel[value_column].hstore.slice(pairs.map { |k, _| k }.to_a)).to_h
+        @slice = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
+          ds.filter(key_column => pl.arg).select(key_column, value_column)
         end
       end
 
       # @api private
-      class SQLite < Sequel
-        def initialize(options)
-          @version = backend.get(::Sequel[:sqlite_version].function)
-          # See https://sqlite.org/lang_UPSERT.html
-          @can_upsert = ::Gem::Version.new(@version) >= ::Gem::Version.new('3.24.0')
-          super
-        end
-
-        def store(key, value, options = {})
-          @table.insert_conflict(:replace).insert(key_column => key, value_column => blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          return super unless @can_upsert
-          update_expr = (::Sequel[@table_name][value_column].cast(Integer) + amount).cast(:blob)
-
-          @backend.transaction do
-            @table.
-              insert_conflict(
-                target: key_column,
-                update: {value_column => update_expr},
-                update_where:
-                  ::Sequel.|(
-                    {value_column => blob("0")},
-                    ::Sequel.~(::Sequel[@table_name][value_column].cast(Integer)) => 0)).
-              insert(key_column => key, value_column => blob(amount.to_s))
-            Integer(load(key))
-          end
-        end
-
-        def merge!(pairs, options = {}, &block)
-          @backend.transaction do
-            pairs = yield_merge_pairs(pairs, &block) if block_given?
-            @table.insert_conflict(:replace).import([key_column, value_column], blob_pairs(pairs).to_a)
-          end
-
-          self
-        end
-      end
+      class IncrementError < ::Sequel::DatabaseError; end
     end
   end
 end