sequel 5.30.0 → 5.31.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22c562c1227d83d1425ef6db9d8bd503595cd97e35036cca335aeb588a00f3df
-  data.tar.gz: 18c96ea22fe23f65b6f85c6efc17ce9b17e783fc8bfaefa498edb7ada25499aa
+  metadata.gz: f7419480f1c01043fb35c490c25cfbbcfaa9b5694ad41462f7af1c5e5e57bdf5
+  data.tar.gz: 7fe799521a27993775f197f15cc38b780c04a3d8d4a9a8ef931da1bea2308779
 SHA512:
-  metadata.gz: 890ae35cd097875a8cab776d7db7760ccb8b21fa0317dd26011a5a49996d378bdd5db68c299967c47c7b066718aca642fb7b606979753a1ac9833ac2d004b02d
-  data.tar.gz: bb685f30c7c4db37441f38cc1e6a729e5d87db86996474bbcb18dd551310ff7751e2abc56db146483e319197bb6381cbf12c6e4e2e6a2079da82ff74ae4aadc9
+  metadata.gz: c3c37683caeb5390eaf614d481be330af8685a07250f4464487d45f0cc0758b94afc28c7008f6ba62f2945f92caf7dc83f2e43907d534e502d16c62e8b0d1c4d
+  data.tar.gz: 49eb980c909fb2490b7e0ec808c0594e84f80593baed607917cd40ed99abab69fc42daf8e7fc5d4691785a0681fa1689c9e1c5130813c0d89cb5e5d638e60cd8

data/CHANGELOG

@@ -1,3 +1,23 @@
+=== 5.31.0 (2020-04-01)
+
+* Fix alter_table drop_constraint :primary_key option on SQLite for non-integer primary keys (jeremyevans)
+
+* Add skip_saving_columns plugin, which supports columns to skip when saving, and skips generated columns by default (joeosburn, jeremyevans) (#1681, #1682)
+
+* Add support for creating partitioned tables in PostgreSQL 10+ using :partition_by and :partition_of options (jeremyevans)
+
+* Dump generated columns as generated columns when using the schema_dumper with :same_db option on PostgreSQL 12+ (jeremyevans) (#1680)
+
+* Ignore defaults for generated columns by default when using the schema dumper (jeremyevans) (#1680)
+
+* Include generated columns in schema on SQLite 3.31+ (jeremyevans)
+
+* Add :generated schema entry on PostgreSQL 12+ and SQLite 3.31+ for whether the columns is generated (jeremyevans)
+
+* Add association_lazy_eager_option plugin for supporting :eager option for association method (jeremyevans)
+
+* Add forbid_lazy_load plugin for forbidding lazy loading of associations, to help find N+1 issues (jeremyevans)
+
 === 5.30.0 (2020-03-01)
 
 * Remove specs and old release notes from the gem to reduce gem size by over 40% (jeremyevans)

data/README.rdoc

@@ -894,7 +894,7 @@ in the most current release.
 
 Sequel fully supports the currently supported versions of Ruby (MRI) and JRuby.  It may
 support unsupported versions of Ruby or JRuby, but such support may be dropped in any
-minor version of keeping it becomes a support issue.  The minimum Ruby version
+minor version if keeping it becomes a support issue.  The minimum Ruby version
 required to run the current version of Sequel is 1.9.2.
 
 == Maintainer

data/doc/postgresql.rdoc

@@ -139,6 +139,77 @@ conversion via a USING clause, and Sequel supports this using the <tt>:using</tt
   # ALTER TABLE "table" ALTER COLUMN "unix_time" TYPE timestamp
   #   USING (CAST('epoch' AS timestamp) + (CAST('1 second' AS interval) * "unix_time"))
 
+=== Creating Partitioned Tables
+
+PostgreSQL allows marking tables as partitioned tables, and adding partitions to such tables. Sequel
+offers support for this.  You can create a partitioned table using the +:partition_by+ option and
++:partition_type+ options (the default partition type is range partitioning):
+
+  DB.create_table(:table1, partition_by: :column, partition_type: :range) do
+    Integer :id
+    Date :column
+  end
+
+  DB.create_table(:table2, partition_by: :column, partition_type: :list) do
+    Integer :id
+    String :column
+  end
+
+  DB.create_table(:table3, partition_by: :column, partition_type: :hash) do
+    Integer :id
+    Integer :column
+  end
+
+To add partitions of other tables, you use the +:partition_of+ option.  This option will use
+a custom DSL specific to partitioning other tables. For range partitioning, you can use the
++from+ and +to+ methods to specify the inclusive beginning and exclusive ending of the
+range of the partition.  You can call the +minvalue+ and +maxvalue+ methods to get the minimum
+and maximum values for the column(s) in the range, useful as arguments to +from+ and +to+:
+
+  DB.create_table(:table1a, partition_of: :table1) do
+    from minvalue
+    to 0
+  end
+  DB.create_table(:table1b, partition_of: :table1) do
+    from 0
+    to 100
+  end
+  DB.create_table(:table1c, partition_of: :table1) do
+    from 100
+    to maxvalue
+  end
+
+For list partitioning, you use the +values_in+ method.  You can also use the +default+ method
+to mark a partition as the default partition:
+
+  DB.create_table(:table2a, partition_of: :table2) do
+    values_in 1, 2, 3
+  end
+  DB.create_table(:table2b, partition_of: :table2) do
+    values_in 4, 5, 6
+  end
+  DB.create_table(:table2c, partition_of: :table2) do
+    default
+  end
+
+For hash partitioning, you use the +modulus+ and +remainder+ methods:
+
+  DB.create_table(:table3a, partition_of: :table3) do
+    modulus 3
+    remainder 0
+  end
+  DB.create_table(:table3b, partition_of: :table3) do
+    modulus 3
+    remainder 1
+  end
+  DB.create_table(:table3c, partition_of: :table3) do
+    modulus 3
+    remainder 2
+  end
+
+There is currently no support for using custom column or table constraints in partitions of
+other tables.  Support may be added in the future.
+
 === Creating Unlogged Tables
 
 PostgreSQL allows users to create unlogged tables, which are faster but not crash safe.  Sequel

data/doc/release_notes/5.31.0.txt

@@ -0,0 +1,148 @@
+= New Features
+
+* A forbid_lazy_load plugin has been added to forbid the lazy loading
+  of model associations if the current object was retreived with other
+  objects.  This plugin helps detect N+1 query issues.  This plugin
+  will raise an error if a lazy load is detected in such cases:
+
+    Album.plugin :forbid_lazy_load
+    Album.one_to_many :tracks
+
+    Album.each do |album|
+      album.tracks
+      # Could be N+1, raises Sequel::Plugins::ForbidLazyLoad::Error
+    end
+
+    Album.first.tracks
+    # Could not be N+1, no error raised
+
+  The forbid_lazy_load plugin is designed to be loaded into the base
+  model class (generally Sequel::Model), and can be loaded only in
+  test mode, or only in certain test mode configurations, so that it
+  does not have any production performance impact.
+
+  Note that an alternative approach that Sequel has supported for many
+  years is the tactical_eager_loading plugin, which automatically
+  eager loads when an N+1 query issue is detected.
+
+* An association_lazy_eager_option plugin has been added which supports
+  the :eager option for the association method.  If the association has
+  not been loaded, this eagerly loads the associations specified by the
+  :eager option when loading the association.  If the association has
+  already been loaded, this option is ignored, with the assumption that
+  whatever loaded the association already used the correct eager
+  loading.  Example:
+
+    Album.plugin :association_lazy_eager_option
+    Album.one_to_many :tracks
+    Track.many_to_one :artist
+
+    album = Album.first
+    album.tracks(:eager=>:artist)
+    # Loads tracks for album, then artist for each track (2 queries)
+
+    album.tracks(:eager=>:artist)
+    # No query issued as association is cached
+
+  You could previously have similar behavior for uncached associations
+  by passing a block to the association method and calling eager on
+  the yielded dataset.  However, that would ignore any cached
+  association, causing redundant loading of the association in such
+  cases.
+
+* On PostgreSQL 10+, creating partitioned tables and partitions of
+  other tables is now supported.
+
+  To create a partitioned table, use the :partition_by option:
+
+    DB.create_table(:table1, partition_by: :date_column,
+                            partition_type: :range) do
+      Integer :id
+      Date :date_column
+    end
+
+    DB.create_table(:table2, partition_by: :string_column,
+                             partition_type: :list) do
+      Integer :id
+      String :string_column
+    end
+
+    DB.create_table(:table3, partition_by: :int_column,
+                             partition_type: :hash) do
+      Integer :id
+      Integer :int_column
+    end
+
+  To add partitions of other tables, use the :partition_of option.
+  This option will use a custom DSL specific to partitions of other
+  tables.
+  
+  For range partitioning, you can use the from and to methods to
+  specify the inclusive beginning and exclusive ending of the range
+  of the partition.  You can call the minvalue and maxvalue methods
+  to get the minimum and maximum values for the column(s) in the
+  range, useful as arguments to from and to:
+
+    DB.create_table(:table1a, partition_of: :table1) do
+      from minvalue
+      to 0
+    end
+    DB.create_table(:table1b, partition_of: :table1) do
+      from 0
+      to 100
+    end
+    DB.create_table(:table1c, partition_of: :table1) do
+      from 100
+      to maxvalue
+    end
+
+  For list partitioning, you use the values_in method.  You can also
+  use the default method to mark a partition as the default partition:
+
+    DB.create_table(:table2a, partition_of: :table2) do
+      values_in 1, 2, 3
+    end
+    DB.create_table(:table2b, partition_of: :table2) do
+      values_in 4, 5, 6
+    end
+    DB.create_table(:table2c, partition_of: :table2) do
+      default
+    end
+
+  For hash partitioning, you use the modulus and remainder methods:
+
+    DB.create_table(:table3a, partition_of: :table3) do
+      modulus 3
+      remainder 0
+    end
+    DB.create_table(:table3b, partition_of: :table3) do
+      modulus 3
+      remainder 1
+    end
+    DB.create_table(:table3c, partition_of: :table3) do
+      modulus 3
+      remainder 2
+    end
+
+* On PostgreSQL 12+ and SQLite 3.31+, column schema hashes now have
+  a :generated entry for whether the column is a generated column.
+
+* The schema_dumper extension now dumps generated columns correctly
+  when using the :same_db option on PostgreSQL 12+.
+
+* A skip_saving_columns plugin has been added.  This allows skipping
+  saving of specific columns for the model.  By default, it skips
+  saving of generated columns, but you can customize the columns
+  that it skips:
+
+    Album.plugin :skip_saving_columns
+    Album.skip_saving_columns = [:some_column]
+
+= Other Improvements
+
+* The alter_table drop_constraint :primary_key option on SQLite now
+  works correctly for non-integer primary keys.
+
+* When an error is raised due to an irreversible migration, the error
+  message now includes the file containing the migration for easier
+  debugging.

data/doc/testing.rdoc

@@ -168,7 +168,6 @@ SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or inte
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
 SEQUEL_MODEL_THROW_FAILURES :: Use the throw_failures plugin when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
-SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the specs
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs

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

@@ -134,6 +134,96 @@ module Sequel
       end
     end
 
+    # Generator used for creating tables that are partitions of other tables.
+    class CreatePartitionOfTableGenerator
+      MINVALUE = Sequel.lit('MINVALUE').freeze
+      MAXVALUE = Sequel.lit('MAXVALUE').freeze
+
+      def initialize(&block)
+        instance_exec(&block)
+      end
+
+      # The minimum value of the data type used in range partitions, useful
+      # as an argument to #from.
+      def minvalue
+        MINVALUE
+      end
+
+      # The minimum value of the data type used in range partitions, useful
+      # as an argument to #to.
+      def maxvalue
+        MAXVALUE
+      end
+
+      # Assumes range partitioning, sets the inclusive minimum value of the range for
+      # this partition.
+      def from(*v)
+        @from = v
+      end
+
+      # Assumes range partitioning, sets the exclusive maximum value of the range for
+      # this partition.
+      def to(*v)
+        @to = v
+      end
+
+      # Assumes list partitioning, sets the values to be included in this partition.
+      def values_in(*v)
+        @in = v
+      end
+
+      # Assumes hash partitioning, sets the modulus for this parition.
+      def modulus(v)
+        @modulus = v
+      end
+
+      # Assumes hash partitioning, sets the remainder for this parition.
+      def remainder(v)
+        @remainder = v
+      end
+
+      # Sets that this is a default partition, where values not in other partitions
+      # are stored.
+      def default
+        @default = true
+      end
+
+      # The from and to values of this partition for a range partition.
+      def range
+        [@from, @to]
+      end
+
+      # The values to include in this partition for a list partition.
+      def list
+        @in
+      end
+
+      # The modulus and remainder to use for this partition for a hash partition.
+      def hash_values
+        [@modulus, @remainder]
+      end
+
+      # Determine the appropriate partition type for this partition by which methods
+      # were called on it.
+      def partition_type
+        raise Error, "Unable to determine partition type, multiple different partitioning methods called" if [@from || @to, @list, @modulus || @remainder, @default].compact.length > 1
+
+        if @from || @to
+          raise Error, "must call both from and to when creating a partition of a table if calling either" unless @from && @to
+          :range
+        elsif @in
+          :list
+        elsif @modulus || @remainder
+          raise Error, "must call both modulus and remainder when creating a partition of a table if calling either" unless @modulus && @remainder
+          :hash
+        elsif @default
+          :default
+        else
+          raise Error, "unable to determine partition type, no partitioning methods called"
+        end
+      end
+    end
+
     # Error raised when Sequel determines a PostgreSQL exclusion constraint has been violated.
     class ExclusionConstraintViolation < Sequel::ConstraintViolation; end
 
@@ -359,6 +449,16 @@ module Sequel
         self << create_schema_sql(name, opts)
       end
 
+      # Support partitions of tables using the :partition_of option.
+      def create_table(name, options=OPTS, &block)
+        if options[:partition_of]
+          create_partition_of_table_from_generator(name, CreatePartitionOfTableGenerator.new(&block), options)
+          return
+        end
+
+        super
+      end
+
       # Create a trigger in the database.  Arguments:
       # table :: the table on which this trigger operates
       # name :: the name of this trigger
@@ -1018,6 +1118,36 @@ module Sequel
         "CREATE#{' OR REPLACE' if opts[:replace] && server_version >= 90000}#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
       end
 
+      # Create a partition of another table, used when the create_table with
+      # the :partition_of option is given.
+      def create_partition_of_table_from_generator(name, generator, options)
+        execute_ddl(create_partition_of_table_sql(name, generator, options))
+      end
+
+      # SQL for creating a partition of another table.
+      def create_partition_of_table_sql(name, generator, options)
+        sql = create_table_prefix_sql(name, options).dup
+
+        sql << " PARTITION OF #{quote_schema_table(options[:partition_of])}"
+
+        case generator.partition_type
+        when :range
+          from, to = generator.range
+          sql << " FOR VALUES FROM #{literal(from)} TO #{literal(to)}"
+        when :list
+          sql << " FOR VALUES IN #{literal(generator.list)}"
+        when :hash
+          mod, remainder = generator.hash_values
+          sql << " FOR VALUES WITH (MODULUS #{literal(mod)}, REMAINDER #{literal(remainder)})"
+        when :default
+          sql << " DEFAULT"
+        end
+
+        sql << create_table_suffix_sql(name, options)
+
+        sql
+      end
+
       # SQL for creating a schema.
       def create_schema_sql(name, opts=OPTS)
         "CREATE SCHEMA #{'IF NOT EXISTS ' if opts[:if_not_exists]}#{quote_identifier(name)}#{" AUTHORIZATION #{literal(opts[:owner])}" if opts[:owner]}"
@@ -1039,25 +1169,36 @@ module Sequel
         "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
       end
 
+      # SQL for creating a table with PostgreSQL specific options
       def create_table_sql(name, generator, options)
-        sql = super
+        "#{super}#{create_table_suffix_sql(name, options)}"
+      end
+
+      # Handle various PostgreSQl specific table extensions such as inheritance,
+      # partitioning, tablespaces, and foreign tables.
+      def create_table_suffix_sql(name, options)
+        sql = String.new
 
         if inherits = options[:inherits]
-          sql += " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
+          sql << " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
+        end
+
+        if partition_by = options[:partition_by]
+          sql << " PARTITION BY #{options[:partition_type]||'RANGE'} #{literal(Array(partition_by))}"
         end
 
         if on_commit = options[:on_commit]
           raise(Error, "can't provide :on_commit without :temp to create_table") unless options[:temp]
           raise(Error, "unsupported on_commit option: #{on_commit.inspect}") unless ON_COMMIT.has_key?(on_commit)
-          sql += " ON COMMIT #{ON_COMMIT[on_commit]}"
+          sql << " ON COMMIT #{ON_COMMIT[on_commit]}"
         end
 
         if tablespace = options[:tablespace]
-          sql += " TABLESPACE #{quote_identifier(tablespace)}"
+          sql << " TABLESPACE #{quote_identifier(tablespace)}"
         end
 
         if server = options[:foreign]
-          sql += " SERVER #{quote_identifier(server)}"
+          sql << " SERVER #{quote_identifier(server)}"
           if foreign_opts = options[:options]
             sql << " OPTIONS (#{foreign_opts.map{|k, v| "#{k} #{literal(v.to_s)}"}.join(', ')})"
           end
@@ -1273,6 +1414,10 @@ module Sequel
 
         if server_version > 100000
           ds = ds.select_append{pg_attribute[:attidentity]}
+
+          if server_version > 120000
+            ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
+          end
         end
 
         ds.map do |row|

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

@@ -184,7 +184,7 @@ module Sequel
 
       # Dataset used for parsing schema
       def _parse_pragma_ds(table_name, opts)
-        metadata_dataset.with_sql("PRAGMA table_info(?)", input_identifier_meth(opts[:dataset]).call(table_name))
+        metadata_dataset.with_sql("PRAGMA table_#{'x' if sqlite_version > 33100}info(?)", input_identifier_meth(opts[:dataset]).call(table_name))
       end
 
       # Run all alter_table commands in a transaction.  This is technically only
@@ -252,7 +252,12 @@ module Sequel
         when :drop_constraint
           case op[:type]
           when :primary_key
-            duplicate_table(table){|columns| columns.each{|s| s[:primary_key] = s[:auto_increment] = nil}}
+            duplicate_table(table) do |columns|
+              columns.each do |s|
+                s[:unique] = false if s[:primary_key]
+                s[:primary_key] = s[:auto_increment] = nil
+              end
+            end
           when :foreign_key
             if op[:columns]
               duplicate_table(table, :skip_foreign_key_columns=>op[:columns])
@@ -420,7 +425,7 @@ module Sequel
         unless unique_columns.empty?
           unique_columns.map!{|c| quote_identifier(c)}
           def_columns.each do |c|
-            c[:unique] = true if unique_columns.include?(quote_identifier(c[:name]))
+            c[:unique] = true if unique_columns.include?(quote_identifier(c[:name])) && c[:unique] != false
           end
         end
         
@@ -466,6 +471,15 @@ module Sequel
       def parse_pragma(table_name, opts)
         pks = 0
         sch = _parse_pragma_ds(table_name, opts).map do |row|
+          if sqlite_version > 33100
+            # table_xinfo PRAGMA used, remove hidden columns
+            # that are not generated columns
+            if row[:generated] = (row.delete(:hidden) != 0)
+              next unless row[:type].end_with?(' GENERATED ALWAYS')
+              row[:type] = row[:type].sub(' GENERATED ALWAYS', '')
+            end
+          end
+
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
@@ -482,6 +496,8 @@ module Sequel
           row
         end
 
+        sch.compact!
+
         if pks > 1
           # SQLite does not allow use of auto increment for tables
           # with composite primary keys, so remove auto_increment

data/lib/sequel/extensions/migration.rb

@@ -176,7 +176,7 @@ module Sequel
         just_raise = true
       end
       if just_raise
-        Proc.new{raise Sequel::Error, 'irreversible migration method used, you may need to write your own down method'}
+        Proc.new{raise Sequel::Error, "irreversible migration method used in #{block.source_location.first}, you may need to write your own down method"}
       else
         actions = @actions.reverse
         Proc.new do

data/lib/sequel/extensions/pg_enum.rb

@@ -40,8 +40,11 @@
 #   DB.schema(:table_name)
 #   [[:column_name, {:type=>:enum, :enum_values=>['value1', 'value2']}]]
 #
-# If the pg_array extension is used, arrays of enums are returned as a
-# PGArray:
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of enum types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_enum
 #
 #   DB.create_table(:table_name) do
 #     column :column_name, 'enum_type_name[]'

data/lib/sequel/extensions/pg_hstore.rb

@@ -74,6 +74,12 @@
 #
 #   DB.extension :pg_hstore
 #
+# This extension integrates with the pg_array extension.  If you plan
+# to use arrays of hstore types, load the pg_array extension before the
+# pg_interval extension:
+#
+#   DB.extension :pg_array, :pg_hstore
+#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #

data/lib/sequel/extensions/schema_dumper.rb

@@ -199,12 +199,18 @@ END_MIG
         end
         type = col_opts.delete(:type)
         col_opts.delete(:size) if col_opts[:size].nil?
-        col_opts[:default] = if schema[:ruby_default].nil?
-          column_schema_to_ruby_default_fallback(schema[:default], options)
+        if schema[:generated]
+          if options[:same_db] && database_type == :postgres
+            col_opts[:generated_always_as] = column_schema_to_ruby_default_fallback(schema[:default], options)
+          end
         else
-          schema[:ruby_default]
+          col_opts[:default] = if schema[:ruby_default].nil?
+            column_schema_to_ruby_default_fallback(schema[:default], options)
+          else
+            schema[:ruby_default]
+          end
+          col_opts.delete(:default) if col_opts[:default].nil?
         end
-        col_opts.delete(:default) if col_opts[:default].nil?
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}

data/lib/sequel/model/base.rb

@@ -1772,14 +1772,12 @@ module Sequel
               before_update
               columns = opts[:columns]
               if columns.nil?
-                if opts[:changed]
-                  cc = changed_columns
-                  columns_updated = @values.reject{|k,v| !cc.include?(k)}
-                  cc.clear
+                columns_updated = if opts[:changed]
+                  _save_update_changed_colums_hash
                 else
-                  columns_updated = _save_update_all_columns_hash
-                  _clear_changed_columns(:update)
+                  _save_update_all_columns_hash
                 end
+                _clear_changed_columns(:update)
               else # update only the specified columns
                 columns = Array(columns)
                 columns_updated = @values.reject{|k, v| !columns.include?(k)}
@@ -1827,6 +1825,14 @@ module Sequel
         v
       end
 
+      # Return a hash of values used when saving changed columns of an
+      # existing object.  Defaults to all of the objects current values
+      # that are recorded as modified.
+      def _save_update_changed_colums_hash
+        cc = changed_columns
+        @values.reject{|k,v| !cc.include?(k)}
+      end
+
       # Validate the object if validating on save. Skips validation
       # completely (including validation hooks) if
       # skip_validation_on_save! has been called on the object,

data/lib/sequel/plugins/association_lazy_eager_option.rb

@@ -0,0 +1,64 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The association_lazy_eager_option plugin supports passing
+    # an +:eager+ option to an association method.  If the related
+    # association is already cached, the cached version will be
+    # returned.  If the association is not already cached, it will
+    # be loaded, and the value of the +:eager+ option will be used
+    # to perform an eager load of the given associations.
+    # the plural versions.
+    #
+    # With Sequel's default behavior, you can already perform an
+    # eager load when lazy loading using a block:
+    #
+    #   obj.association{|ds| ds.eager(:nested_association)}
+    #
+    # However, this will ignore any cached version.  In more
+    # complex software, the association may already be cached
+    # and have the nested association cached inside of it, and
+    # using this callback approach then requires 2 unnecessary
+    # queries. This plugin will not perform any queries if the
+    # association is already cached, preventing duplicate work.
+    # However, you should make sure that an already loaded
+    # association has the nested association already eagerly
+    # loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support the :eager association
+    #   # method option (called before loading subclasses)
+    #   Sequel::Model.plugin :association_lazy_eager_option
+    #
+    #   # Make the Album class support the :eager association
+    #   # method option
+    #   Album.plugin :association_lazy_eager_option
+    module AssociationLazyEagerOption
+      module InstanceMethods
+        # Return a dataset for the association after applying any dynamic callback.
+        def _associated_dataset(opts, dynamic_opts)
+          ds = super
+
+          if eager = dynamic_opts[:eager]
+            ds = ds.eager(eager)
+          end
+
+          ds
+        end
+        
+        # A placeholder literalizer that can be used to load the association, or nil to not use one.
+        def _associated_object_loader(opts, dynamic_opts)
+          return if dynamic_opts[:eager]
+          super
+        end
+
+        # Whether to use a simple primary key lookup on the associated class when loading.
+        def load_with_primary_key_lookup?(opts, dynamic_opts)
+          return false if dynamic_opts[:eager]
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/forbid_lazy_load.rb

@@ -0,0 +1,214 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The forbid_lazy_load plugin forbids lazy loading of associations
+    # for objects in cases where the object wasn't loaded with a
+    # method that only returns a single object.
+    #
+    # The main reason for doing this is it makes it easier to detect
+    # N+1 query issues. Note that Sequel also offers a
+    # tactical_eager_loading plugin which will automatically eagerly
+    # load associations for all objects retrived in the same query
+    # if any object would attempt to lazily load an association. That
+    # approach may be simpler if you are trying to prevent N+1 issues,
+    # though it does retain more objects in memory.
+    #
+    # This plugin offers multiple different ways to forbid lazy
+    # loading.  You can forbid lazy loading associations for individual
+    # model instances:
+    #
+    #   obj = Album[1]
+    #   obj.forbid_lazy_load
+    #   obj.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # +forbid_lazy_load+ is automatically called on instances if the
+    # instances are loaded via a method such as Dataset#all,
+    # Dataset#each, and other methods that load multiple instances
+    # at once.  These are the cases where lazily loading associations
+    # for such instances can cause N+1 issues.
+    #
+    #   Album.all.first.artist
+    #   objs.first.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    #   Album.each do |obj|
+    #     obj.artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #   end
+    #
+    #   Album[1].artist # no error
+    #
+    #   Album.first.artist # no error
+    #
+    # You can allow lazy loading associations for an instance that it
+    # was previously forbidden for:
+    # 
+    #   obj = Album.all.first
+    #   obj.allow_lazy_load
+    #   obj.artist # no error
+    #
+    # You can forbid lazy loading associations on a per-call basis,
+    # even if lazy loading of associations is allowed for the instance:
+    #
+    #   obj = Album[1]
+    #   obj.artist(forbid_lazy_load: true)
+    #   # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # This also works for allowing lazy loading associations for a
+    # specific association load even if it is forbidden for the instance:
+    #  
+    #   obj = Album.all.first
+    #   obj.artist(forbid_lazy_load: false)
+    #   # nothing raised
+    #
+    # You can also forbid lazy loading on a per-association basis using the
+    # +:forbid_lazy_load+ association option with a +true+ value:
+    #
+    #   Album.many_to_one :artist, forbid_lazy_load: true
+    #   Album[1].artist # raises Sequel::Plugins::ForbidLazyLoad::Error
+    #
+    # However, you probably don't want to do this as it will forbid any
+    # lazy loading of the association, even if the loading could not
+    # result in an N+1 issue.
+    #
+    # On the flip side, you can allow lazy loading using the 
+    # +:forbid_lazy_load+ association option with a +false+ value:
+    #
+    #   Album.many_to_one :artist, forbid_lazy_load: false
+    #   Album.all.first.artist # no error
+    #
+    # One reason to do this is when using a plugin like static_cache
+    # on the associated model, where a query is not actually issued
+    # when doing a lazy association load.  To make that particular
+    # case easier, this plugin makes Model.finalize_associations
+    # automatically set the association option if the associated
+    # class uses the static_cache plugin.
+    #
+    # Note that even with this plugin, there can still be N+1 issues,
+    # such as:
+    #
+    #   Album.each do |obj| # 1 query for all albums
+    #     Artist[obj.artist_id] # 1 query per album for each artist
+    #   end
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support forbidding lazy load
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :forbid_lazy_load
+    #
+    #   # Make the Album class support forbidding lazy load
+    #   Album.plugin :forbid_lazy_load
+    module ForbidLazyLoad
+      # Error raised when attempting to lazy load an association when
+      # lazy loading has been forbidden.
+      class Error < StandardError
+      end
+
+      module ClassMethods
+        Plugins.def_dataset_methods(self, :forbid_lazy_load)
+
+        # If the static_cache plugin is used by the associated class for
+        # an association, allow lazy loading that association, since the
+        # lazy association load will use a hash table lookup and not a query.
+        def allow_lazy_load_for_static_cache_associations
+          if defined?(::Sequel::Plugins::StaticCache::ClassMethods)
+            @association_reflections.each_value do |ref|
+              if ref.associated_class.is_a?(::Sequel::Plugins::StaticCache::ClassMethods)
+                ref[:forbid_lazy_load] = false
+              end
+            end
+          end
+        end
+
+        # Allow lazy loading for static cache associations before finalizing.
+        def finalize_associations
+          allow_lazy_load_for_static_cache_associations
+          super
+        end
+      end
+
+      module InstanceMethods
+        # Set this model instance to allow lazy loading of associations.
+        def allow_lazy_load
+          @forbid_lazy_load = false
+          self
+        end
+
+        # Set this model instance to not allow lazy loading of associations.
+        def forbid_lazy_load
+          @forbid_lazy_load = true
+          self
+        end
+
+        private
+
+        # Allow lazy loading for objects returned by singular associations.
+        def _load_associated_object(opts, dynamic_opts)
+          # The implementation that loads these associations does
+          # .all.first, which would result in the object returned being
+          # marked as forbidding lazy load.
+          obj = super
+          obj.allow_lazy_load if obj.is_a?(InstanceMethods)
+          obj
+        end
+
+        # Raise an Error if lazy loading has been forbidden for
+        # the instance, association, or call.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          case dynamic_opts[:forbid_lazy_load]
+          when false
+            # nothing
+          when nil
+            unless dynamic_opts[:reload]
+              case opts[:forbid_lazy_load]
+              when nil
+                raise Error, "lazy loading forbidden for this object (association: #{opts.inspect}, object: #{inspect})" if @forbid_lazy_load
+              when false
+                # nothing
+              else
+                raise Error, "lazy loading forbidden for this association (#{opts.inspect})"
+              end
+            end
+          else
+            raise Error, "lazy loading forbidden for this association method call (association: #{opts.inspect})"
+          end
+
+          super
+        end
+      end
+
+      module DatasetMethods
+        # Mark model instances retrieved in this call as forbidding lazy loading.
+        def each
+          if row_proc
+            super do |obj|
+              obj.forbid_lazy_load if obj.is_a?(InstanceMethods)
+              yield obj
+            end
+          else
+            super
+          end
+        end
+
+        # Mark model instances retrieved in this call as forbidding lazy loading.
+        def with_sql_each(sql)
+          if row_proc
+            super(sql) do |obj|
+              obj.forbid_lazy_load if obj.is_a?(InstanceMethods)
+              yield obj
+            end
+          else
+            super
+          end
+        end
+
+        # Mark model instances retrieved in this call as allowing lazy loading.
+        def with_sql_first(sql)
+          obj = super
+          obj.allow_lazy_load if obj.is_a?(InstanceMethods)
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/skip_saving_columns.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The skip_saving_columms plugin allows skipping specific columns when
+    # saving.  By default, it skips columns that the database schema
+    # indicates are generated columns:
+    #
+    #   # Assume id column, name column, and id2 generated column
+    #   album = Album[1]
+    #   album.id # => 1
+    #   album.name # => 'X'
+    #   album.id2 # => 2
+    #   album.save
+    #   # UPDATE album SET name = 'X' WHERE (id = 1)
+    #
+    # You can override which columns will be skipped:
+    #
+    #   Album.skip_saving_columns = [:name]
+    #   album.save
+    #   # UPDATE album SET id2 = 2 WHERE (id = 1)
+    #
+    # The skipping happens for all usage of Model#save and callers of it (e.g.
+    # Model.create, Model.update).  When using the plugin, the only way to get
+    # it to save a column marked for skipping is to explicitly specify it:
+    #
+    #   album.save(columns: [:name, :id2])
+    #   album.save
+    #   # UPDATE album SET name = 'X', id2 = 2 WHERE (id = 1)
+    #
+    # Usage:
+    #
+    #   # Support skipping saving columns in all Sequel::Model subclasses
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :skip_saving_columns
+    #
+    #   # Support skipping saving columns in the Album class
+    #   Album.plugin :skip_saving_columns
+    module SkipSavingColumns
+      # Setup skipping of the generated columns for a model with an existing dataset.
+      def self.configure(mod)
+        mod.instance_exec do
+          set_skip_saving_generated_columns if @dataset
+        end
+      end
+
+      module ClassMethods
+        # An array of column symbols for columns to skip when saving.
+        attr_reader :skip_saving_columns
+
+        # Over the default array of columns to skip.  Once overridden, future
+        # changes to the class's dataset and future subclasses will automatically
+        # use these overridden columns, instead of introspecting the database schema.
+        def skip_saving_columns=(v) 
+          @_skip_saving_columns_no_override = true
+          @skip_saving_columns = v.dup.freeze
+        end
+
+        Plugins.after_set_dataset(self, :set_skip_saving_generated_columns)
+        Plugins.inherited_instance_variables(self, :@skip_saving_columns=>:dup, :@_skip_saving_columns_no_override=>nil)
+
+        private
+
+        # If the skip saving columns has not been overridden, check the database
+        # schema and automatically skip any generated columns.
+        def set_skip_saving_generated_columns
+          return if @_skip_saving_columns_no_override
+          s = []
+          db_schema.each do |k, v|
+            s << k if v[:generated] 
+          end
+          @skip_saving_columns = s.freeze
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Skip the columns the model has marked to skip when inserting.
+        def _insert_values
+          _save_removed_skipped_columns(Hash[super])
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # all columns.
+        def _save_update_all_columns_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # only changed columns.
+        def _save_update_changed_colums_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Remove any columns the model has marked to skip when saving.
+        def _save_removed_skipped_columns(hash)
+          model.skip_saving_columns.each do |column|
+            hash.delete(column)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 30
+  MINOR = 31
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.30.0
+  version: 5.31.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-01 00:00:00.000000000 Z
+date: 2020-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -178,6 +178,7 @@ extra_rdoc_files:
 - doc/release_notes/5.28.0.txt
 - doc/release_notes/5.29.0.txt
 - doc/release_notes/5.30.0.txt
+- doc/release_notes/5.31.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -229,6 +230,7 @@ files:
 - doc/release_notes/5.29.0.txt
 - doc/release_notes/5.3.0.txt
 - doc/release_notes/5.30.0.txt
+- doc/release_notes/5.31.0.txt
 - doc/release_notes/5.4.0.txt
 - doc/release_notes/5.5.0.txt
 - doc/release_notes/5.6.0.txt
@@ -417,6 +419,7 @@ files:
 - lib/sequel/plugins/active_model.rb
 - lib/sequel/plugins/after_initialize.rb
 - lib/sequel/plugins/association_dependencies.rb
+- lib/sequel/plugins/association_lazy_eager_option.rb
 - lib/sequel/plugins/association_multi_add_remove.rb
 - lib/sequel/plugins/association_pks.rb
 - lib/sequel/plugins/association_proxies.rb
@@ -443,6 +446,7 @@ files:
 - lib/sequel/plugins/empty_failure_backtraces.rb
 - lib/sequel/plugins/error_splitter.rb
 - lib/sequel/plugins/finder.rb
+- lib/sequel/plugins/forbid_lazy_load.rb
 - lib/sequel/plugins/force_encoding.rb
 - lib/sequel/plugins/hook_class_methods.rb
 - lib/sequel/plugins/input_transformer.rb
@@ -471,6 +475,7 @@ files:
 - lib/sequel/plugins/single_table_inheritance.rb
 - lib/sequel/plugins/singular_table_names.rb
 - lib/sequel/plugins/skip_create_refresh.rb
+- lib/sequel/plugins/skip_saving_columns.rb
 - lib/sequel/plugins/split_values.rb
 - lib/sequel/plugins/static_cache.rb
 - lib/sequel/plugins/static_cache_cache.rb