moneta 1.2.0 → 1.4.2

data/lib/moneta/adapters/mongo.rb

@@ -1,12 +1,269 @@
+require 'mongo'
+
 module Moneta
-  # @api private
   module Adapters
-    begin
-      require 'moneta/adapters/mongo/official'
-      Mongo = MongoOfficial
-    rescue LoadError
-      require 'moneta/adapters/mongo/moped'
-      Mongo = MongoMoped
+    # MongoDB backend
+    #
+    # Supports expiration, documents will be automatically removed starting
+    # with mongodb >= 2.2 (see {http://docs.mongodb.org/manual/tutorial/expire-data/}).
+    #
+    # You can store hashes directly using this adapter.
+    #
+    # @example Store hashes
+    #     db = Moneta::Adapters::MongoOfficial.new
+    #     db['key'] = {a: 1, b: 2}
+    #
+    # @api public
+    class Mongo
+      include Defaults
+      include ExpiresSupport
+
+      supports :each_key, :create, :increment
+      attr_reader :backend
+
+      DEFAULT_PORT = 27017
+
+      # @param [Hash] options
+      # @option options [String] :collection ('moneta') MongoDB collection name
+      # @option options [String] :host ('127.0.0.1') MongoDB server host
+      # @option options [String] :user Username used to authenticate
+      # @option options [String] :password Password used to authenticate
+      # @option options [Integer] :port (MongoDB default port) MongoDB server port
+      # @option options [String] :database ('moneta') MongoDB database
+      # @option options [Integer] :expires Default expiration time
+      # @option options [String] :expires_field ('expiresAt') Document field to store expiration time
+      # @option options [String] :value_field ('value') Document field to store value
+      # @option options [String] :type_field ('type') Document field to store value type
+      # @option options [::Mongo::Client] :backend Use existing backend instance
+      # @option options Other options passed to `Mongo::MongoClient#new`
+      def initialize(options = {})
+        self.default_expires = options.delete(:expires)
+        @expires_field = options.delete(:expires_field) || 'expiresAt'
+        @value_field = options.delete(:value_field) || 'value'
+        @type_field = options.delete(:type_field) || 'type'
+
+        collection = options.delete(:collection) || 'moneta'
+
+        if options.key?(:db)
+          warn('Moneta::Adapters::Mongo - the :db option is deprecated and will be removed in a future version. Use :database instead')
+        end
+        database = options.delete(:database) || options.delete(:db) || 'moneta'
+        backend = options[:backend] ||
+          begin
+            host = options.delete(:host) || '127.0.0.1'
+            port = options.delete(:port) || DEFAULT_PORT
+            options[:logger] ||= ::Logger.new(STDERR).tap do |logger|
+              logger.level = ::Logger::ERROR
+            end
+            ::Mongo::Client.new(["#{host}:#{port}"], options)
+          end
+
+        @backend = backend.use(database)
+        @collection = @backend[collection]
+        if @backend.command(buildinfo: 1).documents.first['version'] >= '2.2'
+          @collection.indexes.create_one({ @expires_field => 1 }, expire_after: 0)
+        else
+          warn 'Moneta::Adapters::Mongo - You are using MongoDB version < 2.2, expired documents will not be deleted'
+        end
+      end
+
+      # (see Proxy#load)
+      def load(key, options = {})
+        view = @collection.find(:$and => [
+                                  { _id: to_binary(key) },
+                                  not_expired
+                                ])
+
+        doc = view.limit(1).first
+
+        if doc
+          update_expiry(options, nil) do |expires|
+            view.update_one(:$set => { @expires_field => expires })
+          end
+
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#store)
+      def store(key, value, options = {})
+        key = to_binary(key)
+        @collection.replace_one({ _id: key },
+                                value_to_doc(key, value, options),
+                                upsert: true)
+        value
+      end
+
+      # (see Proxy#each_key)
+      def each_key
+        return enum_for(:each_key) unless block_given?
+        @collection.find.each { |doc| yield from_binary(doc[:_id]) }
+        self
+      end
+
+      # (see Proxy#delete)
+      def delete(key, options = {})
+        key = to_binary(key)
+        if doc = @collection.find(_id: key).find_one_and_delete and
+            !doc[@expires_field] || doc[@expires_field] >= Time.now
+          doc_to_value(doc)
+        end
+      end
+
+      # (see Proxy#increment)
+      def increment(key, amount = 1, options = {})
+        @collection.find_one_and_update({ :$and => [{ _id: to_binary(key) }, not_expired] },
+                                        { :$inc => { @value_field => amount } },
+                                        return_document: :after,
+                                        upsert: true)[@value_field]
+      rescue ::Mongo::Error::OperationFailure
+        tries ||= 0
+        (tries += 1) < 3 ? retry : raise
+      end
+
+      # (see Proxy#create)
+      def create(key, value, options = {})
+        key = to_binary(key)
+        @collection.insert_one(value_to_doc(key, value, options))
+        true
+      rescue ::Mongo::Error::OperationFailure => ex
+        raise unless ex.message =~ /^E11000 / # duplicate key error
+        false
+      end
+
+      # (see Proxy#clear)
+      def clear(options = {})
+        @collection.delete_many
+        self
+      end
+
+      # (see Proxy#close)
+      def close
+        @backend.close
+        nil
+      end
+
+      # (see Proxy#slice)
+      def slice(*keys, **options)
+        view = @collection.find(:$and => [
+                                  { _id: { :$in => keys.map(&method(:to_binary)) } },
+                                  not_expired
+                                ])
+        pairs = view.map { |doc| [from_binary(doc[:_id]), doc_to_value(doc)] }
+
+        update_expiry(options, nil) do |expires|
+          view.update_many(:$set => { @expires_field => expires })
+        end
+
+        pairs
+      end
+
+      # (see Proxy#merge!)
+      def merge!(pairs, options = {})
+        existing = Hash[slice(*pairs.map { |key, _| key })]
+        update_pairs, insert_pairs = pairs.partition { |key, _| existing.key?(key) }
+
+        @collection.insert_many(insert_pairs.map do |key, value|
+          value_to_doc(to_binary(key), value, options)
+        end)
+
+        update_pairs.each do |key, value|
+          value = yield(key, existing[key], value) if block_given?
+          binary = to_binary(key)
+          @collection.replace_one({ _id: binary }, value_to_doc(binary, value, options))
+        end
+
+        self
+      end
+
+      # (see Proxy#fetch_values)
+      def fetch_values(*keys, **options)
+        return values_at(*keys, **options) unless block_given?
+        hash = Hash[slice(*keys, **options)]
+        keys.map do |key|
+          if hash.key?(key)
+            hash[key]
+          else
+            yield key
+          end
+        end
+      end
+
+      # (see Proxy#values_at)
+      def values_at(*keys, **options)
+        hash = Hash[slice(*keys, **options)]
+        keys.map { |key| hash[key] }
+      end
+
+      private
+
+      def doc_to_value(doc)
+        case doc[@type_field]
+        when 'Hash'
+          doc = doc.dup
+          doc.delete('_id')
+          doc.delete(@type_field)
+          doc.delete(@expires_field)
+          doc
+        when 'Number'
+          doc[@value_field]
+        else
+          # In ruby_bson version 2 (and probably up), #to_s no longer returns the binary data
+          from_binary(doc[@value_field])
+        end
+      end
+
+      def value_to_doc(key, value, options)
+        case value
+        when Hash
+          value.merge('_id' => key,
+                      @type_field => 'Hash',
+                      # @expires_field must be a Time object (BSON date datatype)
+                      @expires_field => expires_at(options) || nil)
+        when Float, Integer
+          { '_id' => key,
+            @type_field => 'Number',
+            @value_field => value,
+            # @expires_field must be a Time object (BSON date datatype)
+            @expires_field => expires_at(options) || nil }
+        when String
+          intvalue = value.to_i
+          { '_id' => key,
+            @type_field => 'String',
+            @value_field => intvalue.to_s == value ? intvalue : to_binary(value),
+            # @expires_field must be a Time object (BSON date datatype)
+            @expires_field => expires_at(options) || nil }
+        else
+          raise ArgumentError, "Invalid value type: #{value.class}"
+        end
+      end
+
+      # BSON will use String#force_encoding to make the string 8-bit
+      # ASCII.  This could break unicode text so we should dup in this
+      # case, and it also fails with frozen strings.
+      def to_binary(str)
+        str = str.dup if str.frozen? || str.encoding != Encoding::ASCII_8BIT
+        ::BSON::Binary.new(str)
+      end
+
+      def from_binary(binary)
+        binary.is_a?(::BSON::Binary) ? binary.data : binary.to_s
+      end
+
+      def not_expired
+        {
+          :$or => [
+            { @expires_field => nil },
+            { @expires_field => { :$gte => Time.now } }
+          ]
+        }
+      end
+
+      def update_expiry(options, default)
+        if (expires = expires_at(options, default)) != nil
+          yield(expires || nil)
+        end
+      end
     end
   end
 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
 

data/lib/moneta/adapters/sequel.rb

@@ -7,6 +7,11 @@ module Moneta
     class Sequel
       include Defaults
 
+      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
 
@@ -31,51 +36,20 @@ module Moneta
       #   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
+        @backend = options.delete(:backend) ||
+          connect(extensions: extensions, connection_validation_timeout: connection_validation_timeout, **options)
 
-        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
-
-        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
@@ -227,6 +201,37 @@ module Moneta
 
       protected
 
+      # @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
@@ -324,430 +329,6 @@ module Moneta
 
       # @api private
       class IncrementError < ::Sequel::DatabaseError; end
-
-      # @api private
-      class MySQL < Sequel
-        def store(key, value, options = {})
-          @store.call(key: key, value: 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 row = @load_for_update.call(key: key)
-              # Integer() will raise an exception if the existing value cannot be parsed
-              amount += Integer(row[value_column])
-              @increment_update.call(key: key, value: amount)
-            else
-              @create.call(key: key, value: 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 each_key
-          return super unless block_given? && @each_key_server && @table.respond_to?(:stream)
-          # Order is not required when streaming
-          @table.server(@each_key_server).select(key_column).paged_each do |row|
-            yield row[key_column]
-          end
-          self
-        end
-
-        protected
-
-        def prepare_store
-          @store = @table
-            .on_duplicate_key_update
-            .prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_increment
-          @increment_update = @table
-            .where(key_column => :$key)
-            .prepare(:update, statement_id(:increment_update), value_column => :$value)
-          super
-        end
-      end
-
-      # @api private
-      class Postgres < Sequel
-        def store(key, value, options = {})
-          @store.call(key: key, value: blob(value))
-          value
-        end
-
-        def increment(key, amount = 1, options = {})
-          result = @increment.call(key: key, value: blob(amount.to_s), amount: amount)
-          if row = result.first
-            row[value_column].to_i
-          end
-        end
-
-        def delete(key, options = {})
-          result = @delete.call(key: key)
-          if row = result.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 each_key
-          return super unless block_given? && !@each_key_server && @table.respond_to?(:use_cursor)
-          # With a cursor, this will Just Work.
-          @table.select(key_column).paged_each do |row|
-            yield row[key_column]
-          end
-          self
-        end
-
-        protected
-
-        def prepare_store
-          @store = @table
-            .insert_conflict(target: key_column,
-                             update: { value_column => ::Sequel[:excluded][value_column] })
-            .prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_increment
-          update_expr = ::Sequel[:convert_to].function(
-            (::Sequel[:convert_from].function(
-              ::Sequel[@table_name][value_column],
-              'UTF8'
-            ).cast(Integer) + :$amount).cast(String),
-            'UTF8'
-          )
-
-          @increment = @table
-            .returning(value_column)
-            .insert_conflict(target: key_column, update: { value_column => update_expr })
-            .prepare(:insert, statement_id(:increment), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_delete
-          @delete = @table
-            .returning(value_column)
-            .where(key_column => :$key)
-            .prepare(:delete, statement_id(:delete))
-        end
-      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 = {})
-          if @key
-            row = @key.call(row: @row, key: key) || false
-            row && row[:present]
-          else
-            @key_pl.get(key)
-          end
-        end
-
-        def store(key, value, options = {})
-          @backend.transaction do
-            create_row
-            @store.call(row: @row, pair: ::Sequel.hstore(key => value))
-          end
-          value
-        end
-
-        def load(key, options = {})
-          if row = @load.call(row: @row, key: key)
-            row[:value]
-          end
-        end
-
-        def delete(key, options = {})
-          @backend.transaction do
-            value = load(key, options)
-            @delete.call(row: @row, key: key)
-            value
-          end
-        end
-
-        def increment(key, amount = 1, options = {})
-          @backend.transaction do
-            create_row
-            if row = @increment.call(row: @row, key: key, amount: amount).first
-              row[:value].to_i
-            end
-          end
-        end
-
-        def create(key, value, options = {})
-          @backend.transaction do
-            create_row
-            1 ==
-              if @create
-                @create.call(row: @row, key: key, pair: ::Sequel.hstore(key => value))
-              else
-                @table
-                  .where(key_column => @row)
-                  .exclude(::Sequel[value_column].hstore.key?(key))
-                  .update(value_column => ::Sequel[value_column].hstore.merge(key => value))
-              end
-          end
-        end
-
-        def clear(options = {})
-          @clear.call(row: @row)
-          self
-        end
-
-        def values_at(*keys, **options)
-          if row = @values_at.call(row: @row, keys: ::Sequel.pg_array(keys))
-            row[:values].to_a
-          else
-            []
-          end
-        end
-
-        def slice(*keys, **options)
-          if row = @slice.call(row: @row, keys: ::Sequel.pg_array(keys))
-            row[:pairs].to_h
-          else
-            []
-          end
-        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]
-            @store.call(row: @row, pair: ::Sequel.hstore(hash))
-          end
-
-          self
-        end
-
-        def each_key
-          return enum_for(:each_key) { @size.call(row: @row)[:size] } unless block_given?
-
-          ds =
-            if @each_key_server
-              @table.server(@each_key_server)
-            else
-              @table
-            end
-          ds = ds.order(:skeys) unless @table.respond_to?(:use_cursor)
-          ds.where(key_column => @row)
-            .select(::Sequel[value_column].hstore.skeys)
-            .paged_each do |row|
-              yield row[:skeys]
-            end
-          self
-        end
-
-        protected
-
-        def create_row
-          @create_row.call(row: @row)
-        end
-
-        def create_table
-          key_column = self.key_column
-          value_column = self.value_column
-
-          @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
-        end
-
-        def slice_for_update(pairs)
-          keys = pairs.map { |k, _| k }.to_a
-          if row = @slice_for_update.call(row: @row, keys: ::Sequel.pg_array(keys))
-            row[:pairs].to_h
-          else
-            {}
-          end
-        end
-
-        def prepare_statements
-          super
-          prepare_create_row
-          prepare_clear
-          prepare_values_at
-          prepare_size
-        end
-
-        def prepare_create_row
-          @create_row = @table
-            .insert_ignore
-            .prepare(:insert, statement_id(:hstore_create_row), key_column => :$row, value_column => '')
-        end
-
-        def prepare_clear
-          @clear = @table.where(key_column => :$row).prepare(:update, statement_id(:hstore_clear), value_column => '')
-        end
-
-        def prepare_key
-          if defined?(JRUBY_VERSION)
-            @key_pl = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
-              ds.where(key_column => @row).select(::Sequel[value_column].hstore.key?(pl.arg))
-            end
-          else
-            @key = @table.where(key_column => :$row)
-              .select(::Sequel[value_column].hstore.key?(:$key).as(:present))
-              .prepare(:first, statement_id(:hstore_key))
-          end
-        end
-
-        def prepare_store
-          @store = @table
-            .where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_store), value_column => ::Sequel[value_column].hstore.merge(:$pair))
-        end
-
-        def prepare_increment
-          pair = ::Sequel[:hstore]
-            .function(:$key, (
-              ::Sequel[:coalesce].function(::Sequel[value_column].hstore[:$key].cast(Integer), 0) +
-              :$amount
-            ).cast(String))
-
-          @increment = @table
-            .returning(::Sequel[value_column].hstore[:$key].as(:value))
-            .where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_increment), value_column => ::Sequel.join([value_column, pair]))
-        end
-
-        def prepare_load
-          @load = @table.where(key_column => :$row)
-            .select(::Sequel[value_column].hstore[:$key].as(:value))
-            .prepare(:first, statement_id(:hstore_load))
-        end
-
-        def prepare_delete
-          @delete = @table.where(key_column => :$row)
-            .prepare(:update, statement_id(:hstore_delete), value_column => ::Sequel[value_column].hstore.delete(:$key))
-        end
-
-        def prepare_create
-          # Under JRuby we can't use a prepared statement for queries involving
-          # the hstore `?` (key?) operator.  See
-          # https://stackoverflow.com/questions/11940401/escaping-hstore-contains-operators-in-a-jdbc-prepared-statement
-          return if defined?(JRUBY_VERSION)
-          @create = @table
-            .where(key_column => :$row)
-            .exclude(::Sequel[value_column].hstore.key?(:$key))
-            .prepare(:update, statement_id(:hstore_create), value_column => ::Sequel[value_column].hstore.merge(:$pair))
-        end
-
-        def prepare_values_at
-          @values_at = @table
-            .where(key_column => :$row)
-            .select(::Sequel[value_column].hstore[::Sequel.cast(:$keys, :"text[]")].as(:values))
-            .prepare(:first, statement_id(:hstore_values_at))
-        end
-
-        def prepare_slice
-          slice = @table
-            .where(key_column => :$row)
-            .select(::Sequel[value_column].hstore.slice(:$keys).as(:pairs))
-          @slice = slice.prepare(:first, statement_id(:hstore_slice))
-          @slice_for_update = slice.for_update.prepare(:first, statement_id(:hstore_slice_for_update))
-        end
-
-        def prepare_size
-          @size = @backend
-            .from(@table.where(key_column => :$row)
-                        .select(::Sequel[value_column].hstore.each))
-            .select { count.function.*.as(:size) }
-            .prepare(:first, statement_id(:hstore_size))
-        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
-          @backend.transaction do
-            @increment.call(key: key, value: blob(amount.to_s), amount: amount)
-            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
-
-        protected
-
-        def prepare_store
-          @store = @table
-            .insert_conflict(:replace)
-            .prepare(:insert, statement_id(:store), key_column => :$key, value_column => :$value)
-        end
-
-        def prepare_increment
-          return super unless @can_upsert
-          update_expr = (::Sequel[value_column].cast(Integer) + :$amount).cast(:blob)
-          @increment = @table
-            .insert_conflict(
-              target: key_column,
-              update: { value_column => update_expr },
-              update_where: ::Sequel.|({ value_column => blob("0") },
-                                       { ::Sequel.~(::Sequel[value_column].cast(Integer)) => 0 })
-            )
-            .prepare(:insert, statement_id(:increment), key_column => :$key, value_column => :$value)
-        end
-      end
     end
   end
 end