sequel 5.22.0 → 5.26.0

data/lib/sequel/plugins/dirty.rb

@@ -159,9 +159,9 @@ module Sequel
 
         private
 
-        # Reset the initial values when setting values.
-        def _refresh_set_values(hash)
-          reset_initial_values
+        # Reset initial values when clearing changed columns
+        def _clear_changed_columns(reason)
+          reset_initial_values if reason == :initialize || reason == :refresh
           super
         end
 
@@ -214,12 +214,6 @@ module Sequel
           self
         end
 
-        # Reset the initial values when initializing.
-        def initialize_set(h)
-          super
-          reset_initial_values
-        end
-
         # Array holding column symbols that were not present initially.  This is necessary
         # to differentiate between values that were not present and values that were
         # present but equal to nil.

data/lib/sequel/plugins/insert_conflict.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The insert_conflict plugin allows handling conflicts due to unique
+    # constraints when saving new model instance, using the INSERT ON CONFLICT
+    # support in PostgreSQL 9.5+ and SQLite 3.24.0+. Example:
+    #
+    #   class Album < Sequel::Model
+    #     plugin :insert_conflict
+    #   end
+    #
+    #   Album.new(name: 'Foo', copies_sold: 1000).
+    #     insert_conflict(
+    #       target: :name,
+    #       update: {copies_sold: Sequel[:excluded][:b]}
+    #     ).
+    #     save
+    #
+    # This example will try to insert the album, but if there is an existing
+    # album with the name 'Foo', this will update the copies_sold attribute
+    # for that album.  See the PostgreSQL and SQLite adapter documention for
+    # the options you can pass to the insert_conflict method.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses support insert_conflict
+    #   Sequel::Model.plugin :insert_conflict
+    #
+    #   # Make the Album class support insert_conflict
+    #   Album.plugin :insert_conflict
+    module InsertConflict
+      def self.configure(model)
+        model.instance_exec do
+          if @dataset && !@dataset.respond_to?(:insert_conflict)
+            raise Error, "#{self}'s dataset does not support insert_conflict"
+          end
+        end
+      end
+
+      module InstanceMethods
+        # Set the insert_conflict options to pass to the dataset when inserting. 
+        def insert_conflict(opts=OPTS)
+          raise Error, "Model#insert_conflict is only supported on new model instances" unless new?
+          @insert_conflict_opts = opts
+          self
+        end
+
+        private
+
+        # Set the dataset used for inserting to use INSERT ON CONFLICT
+        # Model#insert_conflict has been called on the instance previously.
+        def _insert_dataset
+          ds = super
+
+          if @insert_conflict_opts
+            ds = ds.insert_conflict(@insert_conflict_opts)
+          end
+
+          ds
+        end
+
+        # Disable the use of prepared insert statements, as they are not compatible
+        # with this plugin.
+        def use_prepared_statements_for?(type)
+          return false if type == :insert || type == :insert_select
+          super if defined?(super)
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/nested_attributes.rb

@@ -113,6 +113,10 @@ module Sequel
         #               value, the attribute hash is ignored.
         # :remove :: Allow disassociation of nested records (can remove the associated
         #            object from the parent object, but not destroy the associated object).
+        # :require_modification :: Whether to require modification of nested objects when
+        #                          updating or deleting them (checking that a single row was
+        #                          updated).  By default, uses the default require_modification
+        #                          setting for the nested object.
         # :transform :: A proc to transform attribute hashes before they are
         #               passed to associated object. Takes two arguments, the parent object and
         #               the attribute hash. Uses the return value as the new attribute hash.
@@ -282,6 +286,9 @@ module Sequel
             obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
+            unless (require_modification = meta[:require_modification]).nil?
+              obj.require_modification = require_modification
+            end
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
             if meta[:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
               nested_attributes_remove(meta, obj, :destroy=>true)

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -45,6 +45,31 @@ module Sequel
     # to be associated to particular column(s), and use a specific error message:
     #
     #   Album.pg_auto_constraint_validation_override(:constraint_name, [:column1], "validation error message")
+    #
+    # Using the pg_auto_constraint_validations plugin requires 5 queries per
+    # model at load time in order to gather the necessary metadata.  For applications
+    # with a large number of models, this can result in a noticeable delay during model
+    # initialization.  To mitigate this issue, you can cache the necessary metadata in
+    # a file with the :cache_file option:
+    #
+    #   Sequel::Model.plugin :pg_auto_constraint_validations, cache_file: 'db/pgacv.cache'
+    #
+    # The file does not have to exist when loading the plugin.  If it exists, the plugin
+    # will load the cache and use the cached results instead of issuing queries if there
+    # is an entry in the cache.  If there is no entry in the cache, it will update the
+    # in-memory cache with the metadata results.  To save the in in-memory cache back to
+    # the cache file, run:
+    #
+    #   Sequel::Model.dump_pg_auto_constraint_validations_cache
+    # 
+    # Note that when using the :cache_file option, it is up to the application to ensure
+    # that the dumped cached metadata reflects the current state of the database.  Sequel
+    # does no checking to ensure this, as checking would take time and the
+    # purpose of this code is to take a shortcut.
+    #
+    # The cached schema is dumped in Marshal format, since it is the fastest
+    # and it handles all ruby objects used in the metadata.  Because of this,
+    # you should not attempt to load the metadata from a untrusted file.
     # 
     # Usage:
     #
@@ -67,13 +92,28 @@ module Sequel
       }.freeze).each_value(&:freeze)
 
       # Setup the constraint violation metadata.  Options:
+      # :cache_file :: File storing cached metadata, to avoid queries for each model
       # :messages :: Override the default error messages for each constraint
       #              violation type (:not_null, :check, :unique, :foreign_key, :referenced_by)
       def self.configure(model, opts=OPTS)
         model.instance_exec do
+          if @pg_auto_constraint_validations_cache_file = opts[:cache_file]
+            @pg_auto_constraint_validations_cache = if ::File.file?(@pg_auto_constraint_validations_cache_file)
+              cache = Marshal.load(File.read(@pg_auto_constraint_validations_cache_file))
+              cache.each_value do |hash|
+                hash.freeze.each_value(&:freeze)
+              end
+            else
+              {}
+            end
+          else
+            @pg_auto_constraint_validations_cache = nil
+          end
+
           setup_pg_auto_constraint_validations
           @pg_auto_constraint_validations_messages = (@pg_auto_constraint_validations_messages || DEFAULT_ERROR_MESSAGES).merge(opts[:messages] || OPTS).freeze
         end
+        nil
       end
 
       module ClassMethods
@@ -85,9 +125,16 @@ module Sequel
         # generated validation failures.
         attr_reader :pg_auto_constraint_validations_messages
 
-        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil)
+        Plugins.inherited_instance_variables(self, :@pg_auto_constraint_validations=>nil, :@pg_auto_constraint_validations_messages=>nil, :@pg_auto_constraint_validations_cache=>nil, :@pg_auto_constraint_validations_cache_file=>nil)
         Plugins.after_set_dataset(self, :setup_pg_auto_constraint_validations)
 
+        # Dump the in-memory cached metadata to the cache file.
+        def dump_pg_auto_constraint_validations_cache
+          raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
+          File.open(file, 'wb'){|f| f.write(Marshal.dump(@pg_auto_constraint_validations_cache))}
+          nil
+        end
+
         # Override the constraint validation columns and message for a given constraint
         def pg_auto_constraint_validation_override(constraint, columns, message)
           pgacv = Hash[@pg_auto_constraint_validations]
@@ -122,39 +169,51 @@ module Sequel
             return
           end
 
-          checks = {}
-          indexes = {}
-          foreign_keys = {}
-          referenced_by = {}
+          cache = @pg_auto_constraint_validations_cache
+          literal_table_name = dataset.literal(table_name)
+          unless cache && (metadata = cache[literal_table_name])
+            checks = {}
+            indexes = {}
+            foreign_keys = {}
+            referenced_by = {}
 
-          db.check_constraints(table_name).each do |k, v|
-            checks[k] = v[:columns].dup.freeze unless v[:columns].empty?
-          end
-          db.indexes(table_name, :include_partial=>true).each do |k, v|
-            if v[:unique]
-              indexes[k] = v[:columns].dup.freeze
+            db.check_constraints(table_name).each do |k, v|
+              checks[k] = v[:columns].dup.freeze unless v[:columns].empty?
+            end
+            db.indexes(table_name, :include_partial=>true).each do |k, v|
+              if v[:unique]
+                indexes[k] = v[:columns].dup.freeze
+              end
+            end
+            db.foreign_key_list(table_name, :schema=>false).each do |fk|
+              foreign_keys[fk[:name]] = fk[:columns].dup.freeze
+            end
+            db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
+              referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
+            end
+
+            schema, table = db[:pg_class].
+              join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
+              get([:nspname, :relname])
+
+            metadata = {
+              :schema=>schema,
+              :table=>table,
+              :check=>checks,
+              :unique=>indexes,
+              :foreign_key=>foreign_keys,
+              :referenced_by=>referenced_by,
+              :overrides=>OPTS
+            }.freeze
+            metadata.each_value(&:freeze)
+
+            if cache
+              cache[literal_table_name] = metadata
             end
-          end
-          db.foreign_key_list(table_name, :schema=>false).each do |fk|
-            foreign_keys[fk[:name]] = fk[:columns].dup.freeze
-          end
-          db.foreign_key_list(table_name, :reverse=>true, :schema=>false).each do |fk|
-            referenced_by[[fk[:schema], fk[:table], fk[:name]].freeze] = fk[:key].dup.freeze
           end
 
-          schema, table = db[:pg_class].
-            join(:pg_namespace, :oid=>:relnamespace, db.send(:regclass_oid, table_name)=>:oid).
-            get([:nspname, :relname])
-
-          (@pg_auto_constraint_validations = {
-            :schema=>schema,
-            :table=>table,
-            :check=>checks,
-            :unique=>indexes,
-            :foreign_key=>foreign_keys,
-            :referenced_by=>referenced_by,
-            :overrides=>OPTS
-          }.freeze).each_value(&:freeze)
+          @pg_auto_constraint_validations = metadata
+          nil
         end
       end
 

data/lib/sequel/plugins/sharding.rb

@@ -107,12 +107,18 @@ module Sequel
         # previous row_proc, but calls set_server on the output of that row_proc,
         # ensuring that objects retrieved by a specific shard know which shard they
         # are tied to.
-        def server(s)
-          ds = super
-          if rp = row_proc
-            ds = ds.with_row_proc(proc{|r| rp.call(r).set_server(s)})
+        def row_proc
+          rp = super
+          if rp
+            case server = db.pool.send(:pick_server, opts[:server])
+            when nil, :default, :read_only
+              # nothing
+            else
+              old_rp = rp
+              rp = proc{|r| old_rp.call(r).set_server(server)}
+            end
           end
-          ds
+          rp 
         end
       end
     end

data/lib/sequel/plugins/static_cache.rb

@@ -211,18 +211,23 @@ module Sequel
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
         private
 
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
         # Return the frozen object with the given pk, or nil if no such object exists
         # in the cache, without issuing a database query.
         def primary_key_lookup(pk)

data/lib/sequel/plugins/static_cache_cache.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The static_cache_cache plugin allows for caching the row content for subclasses
+    # that use the static cache plugin (or just the current class).  Using this plugin
+    # can avoid the need to query the database every time loading the plugin into a
+    # model, which can save time when you have a lot of models using the static_cache
+    # plugin.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses that use the static_cache plugin use
+    #   # the cached values in the given file
+    #   Sequel::Model.plugin :static_cache_cache, "static_cache.cache"
+    #
+    #   # Make the AlbumType model the cached values in the given file,
+    #   # should be loaded before the static_cache plugin
+    #   AlbumType.plugin :static_cache_cache, "static_cache.cache"
+    module StaticCacheCache
+      def self.configure(model, file)
+        model.instance_variable_set(:@static_cache_cache_file, file)
+        model.instance_variable_set(:@static_cache_cache, File.exist?(file) ? Marshal.load(File.read(file)) : {})
+      end
+
+      module ClassMethods
+        # Dump the in-memory cached rows to the cache file.
+        def dump_static_cache_cache
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          nil
+        end
+
+        Plugins.inherited_instance_variables(self, :@static_cache_cache_file=>nil, :@static_cache_cache=>nil)
+
+        private
+
+        # Load the rows for the model from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_static_cache_rows
+          if rows = Sequel.synchronize{@static_cache_cache[name]}
+            rows.map{|row| call(row)}.freeze
+          else
+            rows = dataset.all.freeze
+            raw_rows = rows.map(&:values)
+            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            rows
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/typecast_on_load.rb

@@ -41,7 +41,9 @@ module Sequel
         # Typecast values using #load_typecast when the values are retrieved
         # from the database.
         def call(values)
-          super.load_typecast
+          o = super.load_typecast
+          o.send(:_clear_changed_columns, :initialize)
+          o
         end
 
         # Freeze typecast on load columns when freezing model class.
@@ -63,7 +65,6 @@ module Sequel
               set_column_value("#{c}=", v)
             end
           end
-          _changed_columns.clear
           self
         end
 

data/lib/sequel/sql.rb

@@ -788,8 +788,10 @@ module Sequel
       def coerce(other)
         if other.is_a?(Numeric)
           [SQL::NumericExpression.new(:NOOP, other), self]
-        else
+        elsif defined?(super)
           super 
+        else
+          [self, other]
         end
       end
 

data/lib/sequel/timezones.rb

@@ -54,7 +54,14 @@ module Sequel
             convert_output_datetime_other(v, output_timezone)
           end
         else
-          v.public_send(output_timezone == :utc ? :getutc : :getlocal)
+          case output_timezone
+          when :utc
+            v.getutc
+          when :local
+            v.getlocal
+          else
+            convert_output_time_other(v, output_timezone)
+          end
         end
       else
         v
@@ -110,7 +117,7 @@ module Sequel
     # same time and just modifying the timezone.
     def convert_input_datetime_no_offset(v, input_timezone)
       case input_timezone
-      when :utc, nil
+      when nil, :utc
         v # DateTime assumes UTC if no offset is given
       when :local
         offset = local_offset_for_datetime(v)
@@ -119,7 +126,7 @@ module Sequel
         convert_input_datetime_other(v, input_timezone)
       end
     end
-    
+
     # Convert the given +DateTime+ to the given input_timezone that is not supported
     # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
     # Can be overridden in extensions.
@@ -127,6 +134,13 @@ module Sequel
       raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
     end
     
+    # Convert the given +Time+ to the given input_timezone that is not supported
+    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
+    # Can be overridden in extensions.
+    def convert_input_time_other(v, input_timezone)
+      raise InvalidValue, "Invalid input_timezone: #{input_timezone.inspect}"
+    end
+    
     # Converts the object from a +String+, +Array+, +Date+, +DateTime+, or +Time+ into an
     # instance of <tt>Sequel.datetime_class</tt>.  If given an array or a string that doesn't
     # contain an offset, assume that the array/string is already in the given +input_timezone+.
@@ -139,12 +153,17 @@ module Sequel
         else
           # Correct for potentially wrong offset if string doesn't include offset
           if v2.is_a?(DateTime)
-            v2 = convert_input_datetime_no_offset(v2, input_timezone)
+            convert_input_datetime_no_offset(v2, input_timezone)
           else
-            # Time assumes local time if no offset is given
-            v2 = v2.getutc + v2.utc_offset if input_timezone == :utc
+            case input_timezone
+            when nil, :local
+              v2
+            when :utc
+              (v2 + v2.utc_offset).utc
+            else
+              convert_input_time_other((v2 + v2.utc_offset).utc, input_timezone)
+            end
           end
-          v2
         end
       when Array
         y, mo, d, h, mi, s, ns, off = v
@@ -155,8 +174,18 @@ module Sequel
           else
             convert_input_datetime_no_offset(DateTime.civil(y, mo, d, h, mi, s), input_timezone)
           end
+        elsif off
+          s += Rational(ns, 1000000000) if ns
+          Time.new(y, mo, d, h, mi, s, (off*86400).to_i)
         else
-          Time.public_send(input_timezone == :utc ? :utc : :local, y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          case input_timezone
+          when nil, :local
+            Time.local(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          when :utc
+            Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0))
+          else
+            convert_input_time_other(Time.utc(y, mo, d, h, mi, s, (ns ? ns / 1000.0 : 0)), input_timezone)
+          end
         end
       when Hash
         ary = [:year, :month, :day, :hour, :minute, :second, :nanos].map{|x| (v[x] || v[x.to_s]).to_i}
@@ -188,23 +217,33 @@ module Sequel
       raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
     end
     
+    # Convert the given +Time+ to the given output_timezone that is not supported
+    # by default (i.e. one other than +nil+, <tt>:local</tt>, or <tt>:utc</tt>).  Raises an +InvalidValue+ by default.
+    # Can be overridden in extensions.
+    def convert_output_time_other(v, output_timezone)
+      raise InvalidValue, "Invalid output_timezone: #{output_timezone.inspect}"
+    end
+    
     # Convert the timezone setter argument.  Returns argument given by default,
     # exists for easier overriding in extensions.
     def convert_timezone_setter_arg(tz)
       tz
     end
 
-    # Takes a DateTime dt, and returns the correct local offset for that dt, daylight savings included.
+    # Takes a DateTime dt, and returns the correct local offset for that dt, daylight savings included, in fraction of a day.
     def local_offset_for_datetime(dt)
       time_offset_to_datetime_offset Time.local(dt.year, dt.month, dt.day, dt.hour, dt.min, dt.sec).utc_offset
     end
 
     # Caches offset conversions to avoid excess Rational math.
     def time_offset_to_datetime_offset(offset_secs)
-      @local_offsets ||= {}
-      @local_offsets[offset_secs] ||= Rational(offset_secs, 86400)
+      if offset = Sequel.synchronize{@local_offsets[offset_secs]}
+        return offset
+      end
+      Sequel.synchronize{@local_offsets[offset_secs] = Rational(offset_secs, 86400)}
     end
   end
 
+  @local_offsets = {}
   extend Timezones
 end