moneta 1.1.0 → 1.4.0

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[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
+    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[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
+    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: @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
+    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(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

data/lib/moneta/adapters/sqlite.rb

@@ -30,14 +30,24 @@ module Moneta
           @backend.journal_mode = journal_mode.to_s
         end
         @stmts =
-          [@exists  = @backend.prepare("select exists(select 1 from #{@table} where k = ?)"),
-           @select  = @backend.prepare("select v from #{@table} where k = ?"),
+          [@exists = @backend.prepare("select exists(select 1 from #{@table} where k = ?)"),
+           @select = @backend.prepare("select v from #{@table} where k = ?"),
            @replace = @backend.prepare("replace into #{@table} values (?, ?)"),
-           @delete  = @backend.prepare("delete from #{@table} where k = ?"),
-           @clear   = @backend.prepare("delete from #{@table}"),
-           @create  = @backend.prepare("insert into #{@table} values (?, ?)"),
-           @keys    = @backend.prepare("select k from #{@table}"),
-           @count   = @backend.prepare("select count(*) from #{@table}")]
+           @delete = @backend.prepare("delete from #{@table} where k = ?"),
+           @clear = @backend.prepare("delete from #{@table}"),
+           @create = @backend.prepare("insert into #{@table} values (?, ?)"),
+           @keys = @backend.prepare("select k from #{@table}"),
+           @count = @backend.prepare("select count(*) from #{@table}")]
+
+        version = @backend.execute("select sqlite_version()").first.first
+        if @can_upsert = ::Gem::Version.new(version) >= ::Gem::Version.new('3.24.0')
+          @stmts << (@increment = @backend.prepare <<-SQL)
+            insert into #{@table} values (?, ?)
+            on conflict (k)
+            do update set v = cast(cast(v as integer) + ? as blob)
+            where v = '0' or v = X'30' or cast(v as integer) != 0
+          SQL
+        end
       end
 
       # (see Proxy#key?)
@@ -66,7 +76,11 @@ module Moneta
 
       # (see Proxy#increment)
       def increment(key, amount = 1, options = {})
-        @backend.transaction(:exclusive) { return super }
+        @backend.transaction(:exclusive) { return super } unless @can_upsert
+        @backend.transaction do
+          @increment.execute!(key, amount.to_s, amount)
+          return Integer(load(key))
+        end
       end
 
       # (see Proxy#clear)
@@ -77,7 +91,7 @@ module Moneta
 
       # (see Default#create)
       def create(key, value, options = {})
-        @create.execute!(key,value)
+        @create.execute!(key, value)
         true
       rescue SQLite3::ConstraintException
         # If you know a better way to detect whether an insert-ignore
@@ -88,7 +102,7 @@ module Moneta
 
       # (see Proxy#close)
       def close
-        @stmts.each {|s| s.close }
+        @stmts.each { |s| s.close }
         @backend.close
         nil
       end
@@ -120,7 +134,7 @@ module Moneta
 
       # (see Proxy#merge!)
       def merge!(pairs, options = {})
-        transaction = if block_given?; @backend.transaction end
+        transaction = @backend.transaction if block_given?
 
         if block_given?
           existing = Hash[slice(*pairs.map { |k, _| k }.to_a)]