moneta 1.0.0 → 1.5.1

data/lib/moneta/adapters/riak.rb

@@ -5,21 +5,20 @@ module Moneta
     # Riak backend
     # @api public
     # @author Potapov Sergey (aka Blake)
-    class Riak
-      include Defaults
+    class Riak < Adapter
+      config :bucket, default: 'moneta'
+      config :content_type, default: 'application/octet-stream'
 
-      attr_reader :backend
+      backend { |**options| ::Riak::Client.new(options) }
 
       # @param [Hash] options
       # @option options [String] :bucket ('moneta') Bucket name
       # @option options [String] :content_type ('application/octet-stream') Default content type
-      # @option options All other options passed to `Riak::Client#new`
       # @option options [::Riak::Client] :backend Use existing backend instance
+      # @option options All other options passed to `Riak::Client#new`
       def initialize(options = {})
-        bucket = options.delete(:bucket) || 'moneta'
-        @content_type = options.delete(:content_type) || 'application/octet-stream'
-        @backend = options[:backend] || ::Riak::Client.new(options)
-        @bucket = @backend.bucket(bucket)
+        super
+        @bucket = backend.bucket(config.bucket)
       end
 
       # (see Proxy#key?)
@@ -30,7 +29,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
 
@@ -44,7 +43,7 @@ module Moneta
       # (see Proxy#store)
       def store(key, value, options = {})
         obj = ::Riak::RObject.new(@bucket, key)
-        obj.content_type = options[:content_type] || @content_type
+        obj.content_type = options[:content_type] || config.content_type
         obj.raw_data = value
         obj.store(options.dup)
         value
@@ -53,7 +52,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/sdbm.rb

@@ -4,23 +4,17 @@ module Moneta
   module Adapters
     # SDBM backend
     # @api public
-    class SDBM < Memory
-      # @param [Hash] options
-      # @option options [String] :file Database file
-      # @option options [::SDBM] :backend Use existing backend instance
-      def initialize(options = {})
-        @backend = options[:backend] ||
-          begin
-            raise ArgumentError, 'Option :file is required' unless options[:file]
-            ::SDBM.new(options[:file])
-          end
-      end
+    class SDBM < Adapter
+      include DBMAdapter
+      include IncrementSupport
+      include CreateSupport
+      include EachKeySupport
 
-      # (see Proxy#close)
-      def close
-        @backend.close
-        nil
-      end
+      # @!method initialize(options = {})
+      #   @param [Hash] options
+      #   @option options [String] :file Database file
+      #   @option options [::SDBM] :backend Use existing backend instance
+      backend { |file:| ::SDBM.new(file) }
     end
   end
 end

data/lib/moneta/adapters/sequel/mysql.rb

@@ -0,0 +1,66 @@
+module Moneta
+  module Adapters
+    class Sequel
+      # @api private
+      module MySQL
+        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[config.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([config.key_column, config.value_column], blob_pairs(pairs).to_a)
+          end
+
+          self
+        end
+
+        def each_key
+          return super unless block_given? && config.each_key_server && @table.respond_to?(:stream)
+          # Order is not required when streaming
+          @table.server(config.each_key_server).select(config.key_column).paged_each do |row|
+            yield row[config.key_column]
+          end
+          self
+        end
+
+        protected
+
+        def prepare_store
+          @store = @table
+            .on_duplicate_key_update
+            .prepare(:insert, statement_id(:store), config.key_column => :$key, config.value_column => :$value)
+        end
+
+        def prepare_increment
+          @increment_update = @table
+            .where(config.key_column => :$key)
+            .prepare(:update, statement_id(:increment_update), config.value_column => :$value)
+          super
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sequel/postgres.rb

@@ -0,0 +1,80 @@
+module Moneta
+  module Adapters
+    # @api public
+    class Sequel
+      # @api private
+      module Postgres
+        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[config.value_column].to_i
+          end
+        end
+
+        def delete(key, options = {})
+          result = @delete.call(key: key)
+          if row = result.first
+            row[config.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: config.key_column,
+                               update: { config.value_column => ::Sequel[:excluded][config.value_column] })
+              .import([config.key_column, config.value_column], blob_pairs(pairs).to_a)
+          end
+
+          self
+        end
+
+        def each_key
+          return super unless block_given? && !config.each_key_server && @table.respond_to?(:use_cursor)
+          # With a cursor, this will Just Work.
+          @table.select(config.key_column).paged_each do |row|
+            yield row[config.key_column]
+          end
+          self
+        end
+
+        protected
+
+        def prepare_store
+          @store = @table
+            .insert_conflict(target: config.key_column,
+                             update: { config.value_column => ::Sequel[:excluded][config.value_column] })
+            .prepare(:insert, statement_id(:store), config.key_column => :$key, config.value_column => :$value)
+        end
+
+        def prepare_increment
+          update_expr = ::Sequel[:convert_to].function(
+            (::Sequel[:convert_from].function(
+              ::Sequel[config.table][config.value_column],
+              'UTF8'
+            ).cast(Integer) + :$amount).cast(String),
+            'UTF8'
+          )
+
+          @increment = @table
+            .returning(config.value_column)
+            .insert_conflict(target: config.key_column, update: { config.value_column => update_expr })
+            .prepare(:insert, statement_id(:increment), config.key_column => :$key, config.value_column => :$value)
+        end
+
+        def prepare_delete
+          @delete = @table
+            .returning(config.value_column)
+            .where(config.key_column => :$key)
+            .prepare(:delete, statement_id(:delete))
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sequel/postgres_hstore.rb

@@ -0,0 +1,240 @@
+::Sequel.extension :pg_hstore_ops
+
+module Moneta
+  module Adapters
+    class Sequel
+      # @api private
+      module PostgresHStore
+        def self.extended(mod)
+          mod.backend.extension :pg_hstore
+          mod.backend.extension :pg_array
+        end
+
+        def key?(key, options = {})
+          if @key
+            row = @key.call(row: config.hstore, 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: config.hstore, pair: ::Sequel.hstore(key => value))
+          end
+          value
+        end
+
+        def load(key, options = {})
+          if row = @load.call(row: config.hstore, key: key)
+            row[:value]
+          end
+        end
+
+        def delete(key, options = {})
+          @backend.transaction do
+            value = load(key, options)
+            @delete.call(row: config.hstore, key: key)
+            value
+          end
+        end
+
+        def increment(key, amount = 1, options = {})
+          @backend.transaction do
+            create_row
+            if row = @increment.call(row: config.hstore, 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: config.hstore, key: key, pair: ::Sequel.hstore(key => value))
+              else
+                @table
+                  .where(config.key_column => config.hstore)
+                  .exclude(::Sequel[config.value_column].hstore.key?(key))
+                  .update(config.value_column => ::Sequel[config.value_column].hstore.merge(key => value))
+              end
+          end
+        end
+
+        def clear(options = {})
+          @clear.call(row: config.hstore)
+          self
+        end
+
+        def values_at(*keys, **options)
+          if row = @values_at.call(row: config.hstore, keys: ::Sequel.pg_array(keys))
+            row[:values].to_a
+          else
+            []
+          end
+        end
+
+        def slice(*keys, **options)
+          if row = @slice.call(row: config.hstore, 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: config.hstore, pair: ::Sequel.hstore(hash))
+          end
+
+          self
+        end
+
+        def each_key
+          return enum_for(:each_key) { @size.call(row: config.hstore)[:size] } unless block_given?
+
+          ds =
+            if config.each_key_server
+              @table.server(config.each_key_server)
+            else
+              @table
+            end
+          ds = ds.order(:skeys) unless @table.respond_to?(:use_cursor)
+          ds.where(config.key_column => config.hstore)
+            .select(::Sequel[config.value_column].hstore.skeys)
+            .paged_each do |row|
+              yield row[:skeys]
+            end
+          self
+        end
+
+        protected
+
+        def create_row
+          @create_row.call(row: config.hstore)
+        end
+
+        def create_table
+          key_column = config.key_column
+          value_column = config.value_column
+
+          @backend.create_table?(config.table) 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: config.hstore, 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), config.key_column => :$row, config.value_column => '')
+        end
+
+        def prepare_clear
+          @clear = @table.where(config.key_column => :$row).prepare(:update, statement_id(:hstore_clear), config.value_column => '')
+        end
+
+        def prepare_key
+          if defined?(JRUBY_VERSION)
+            @key_pl = ::Sequel::Dataset::PlaceholderLiteralizer.loader(@table) do |pl, ds|
+              ds.where(config.key_column => config.hstore).select(::Sequel[config.value_column].hstore.key?(pl.arg))
+            end
+          else
+            @key = @table.where(config.key_column => :$row)
+              .select(::Sequel[config.value_column].hstore.key?(:$key).as(:present))
+              .prepare(:first, statement_id(:hstore_key))
+          end
+        end
+
+        def prepare_store
+          @store = @table
+            .where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_store), config.value_column => ::Sequel[config.value_column].hstore.merge(:$pair))
+        end
+
+        def prepare_increment
+          pair = ::Sequel[:hstore]
+            .function(:$key, (
+              ::Sequel[:coalesce].function(::Sequel[config.value_column].hstore[:$key].cast(Integer), 0) +
+              :$amount
+            ).cast(String))
+
+          @increment = @table
+            .returning(::Sequel[config.value_column].hstore[:$key].as(:value))
+            .where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_increment), config.value_column => ::Sequel.join([config.value_column, pair]))
+        end
+
+        def prepare_load
+          @load = @table.where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore[:$key].as(:value))
+            .prepare(:first, statement_id(:hstore_load))
+        end
+
+        def prepare_delete
+          @delete = @table.where(config.key_column => :$row)
+            .prepare(:update, statement_id(:hstore_delete), config.value_column => ::Sequel[config.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(config.key_column => :$row)
+            .exclude(::Sequel[config.value_column].hstore.key?(:$key))
+            .prepare(:update, statement_id(:hstore_create), config.value_column => ::Sequel[config.value_column].hstore.merge(:$pair))
+        end
+
+        def prepare_values_at
+          @values_at = @table
+            .where(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore[::Sequel.cast(:$keys, :"text[]")].as(:values))
+            .prepare(:first, statement_id(:hstore_values_at))
+        end
+
+        def prepare_slice
+          slice = @table
+            .where(config.key_column => :$row)
+            .select(::Sequel[config.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(config.key_column => :$row)
+            .select(::Sequel[config.value_column].hstore.each))
+            .select { count.function.*.as(:size) }
+            .prepare(:first, statement_id(:hstore_size))
+        end
+      end
+    end
+  end
+end

data/lib/moneta/adapters/sequel/sqlite.rb

@@ -0,0 +1,57 @@
+module Moneta
+  module Adapters
+    class Sequel
+      # @api private
+      module SQLite
+        def self.extended(mod)
+          version = mod.backend.get(::Sequel[:sqlite_version].function)
+          # See https://sqlite.org/lang_UPSERT.html
+          mod.instance_variable_set(:@can_upsert, ::Gem::Version.new(version) >= ::Gem::Version.new('3.24.0'))
+        end
+
+        def store(key, value, options = {})
+          @table.insert_conflict(:replace).insert(config.key_column => key, config.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([config.key_column, config.value_column], blob_pairs(pairs).to_a)
+          end
+
+          self
+        end
+
+        protected
+
+        def prepare_store
+          @store = @table
+            .insert_conflict(:replace)
+            .prepare(:insert, statement_id(:store), config.key_column => :$key, config.value_column => :$value)
+        end
+
+        def prepare_increment
+          return super unless @can_upsert
+          update_expr = (::Sequel[config.value_column].cast(Integer) + :$amount).cast(:blob)
+          @increment = @table
+            .insert_conflict(
+              target: config.key_column,
+              update: { config.value_column => update_expr },
+              update_where: ::Sequel.|({ config.value_column => blob("0") },
+                                       { ::Sequel.~(::Sequel[config.value_column].cast(Integer)) => 0 })
+            )
+            .prepare(:insert, statement_id(:increment), config.key_column => :$key, config.value_column => :$value)
+        end
+      end
+    end
+  end
+end