sequel 4.49.0 → 5.3.0

data/lib/sequel/plugins/prepared_statements.rb

@@ -3,13 +3,11 @@
 module Sequel
   module Plugins
     # The prepared_statements plugin modifies the model to use prepared statements for
-    # instance level saves (inserts and updates).  It also will use prepared statements for
-    # deletes, refreshes, and class level lookups by primary key, if it thinks that using
-    # a prepared statement will be faster in such cases.
+    # instance level inserts and updates.
     #
     # Note that this plugin is unsafe in some circumstances, as it can allow up to
     # 2^N prepared statements to be created for each type of insert and update query, where
-    # N is the number of colums in the table. It is recommended that you use the
+    # N is the number of columns in the table. It is recommended that you use the
     # +prepared_statements_safe+ plugin in addition to this plugin to reduce the number
     # of prepared statements that can be created, unless you tightly control how your
     # model instances are saved.
@@ -32,12 +30,11 @@ module Sequel
 
       # Setup the datastructure used to hold the prepared statements in the model.
       def self.apply(model)
-        # SEQUEL5: Drop Support for :fixed/:lookup_sql SQL
-        model.instance_variable_set(:@prepared_statements, {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}.freeze)
+        model.instance_variable_set(:@prepared_statements, {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze)
       end
 
       module ClassMethods
-        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}.freeze})
+        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}}.freeze})
 
         private
 
@@ -48,7 +45,7 @@ module Sequel
           meth = type == :insert_select ? :returning : :select
           s = ds.opts[meth]
           if f && f.length == 1 && !ds.opts[:join] && (!s || s.empty?)
-            ds = ds.send(meth, *columns.map{|c| Sequel.identifier(c)})
+            ds = ds.public_send(meth, *columns.map{|c| Sequel.identifier(c)})
           end 
           
           prepare_statement(ds, type, vals)
@@ -62,13 +59,7 @@ module Sequel
 
         # Return a sorted array of columns for use as a hash key.
         def prepared_columns(cols)
-          RUBY_VERSION >= '1.9' ? cols.sort : cols.sort_by(&:to_s)
-        end
-
-        # Return a prepared statement that can be used to delete a row from this model's dataset.
-        def prepared_delete
-          # SEQUEL5: Remove
-          cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}
+          cols.sort
         end
 
         # Return a prepared statement that can be used to insert a row using the given columns.
@@ -84,18 +75,6 @@ module Sequel
           end
         end
 
-        # Return a prepared statement that can be used to lookup a row solely based on the primary key.
-        def prepared_lookup
-          # SEQUEL5: Remove
-          cached_prepared_statement(:fixed, :lookup){prepare_explicit_statement(filter(prepared_statement_key_array(primary_key)), :first)}
-        end
-
-        # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
-        def prepared_refresh
-          # SEQUEL5: Remove
-          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).where(prepared_statement_key_array(primary_key)), :first)}
-        end
-
         # Return an array of two element arrays with the column symbol as the first entry and the
         # placeholder symbol as the second entry.
         def prepared_statement_key_array(keys)
@@ -120,14 +99,7 @@ module Sequel
 
         # Return a prepared statement that can be used to update row using the given columns.
         def prepared_update(cols)
-          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
-        end
-
-        # Use a prepared statement to query the database for the row matching the given primary key.
-        def primary_key_lookup(pk)
-          return super unless use_prepared_statements_for_pk_lookup?
-          # SEQUEL5: Remove
-          prepared_lookup.call(primary_key_hash(pk))
+          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(where(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
         end
 
         # If a prepared statement has already been cached for the given type and subtype,
@@ -153,16 +125,6 @@ module Sequel
       module InstanceMethods
         private
 
-        # Use a prepared statement to delete the row.
-        def _delete_without_checking
-          # SEQUEL5: Remove
-          if use_prepared_statements_for?(:delete)
-            _set_prepared_statement_server(model.send(:prepared_delete)).call(pk_hash)
-          else
-            super
-          end
-        end
-
         # Use a prepared statement to insert the values into the model's dataset.
         def _insert_raw(ds)
           if use_prepared_statements_for?(:insert)
@@ -184,16 +146,6 @@ module Sequel
           end
         end
 
-        # Use a prepared statement to refresh this model's column values.
-        def _refresh_get(ds)
-          # SEQUEL5: Remove
-          if use_prepared_statements_for?(:refresh)
-            _set_prepared_statement_server(model.send(:prepared_refresh)).call(pk_hash)
-          else
-            super
-          end
-        end
-
         # Use a prepared statement to update this model's columns in the database.
         def _update_without_checking(columns)
           if use_prepared_statements_for?(:update)
@@ -213,7 +165,7 @@ module Sequel
         end
 
         # Whether prepared statements should be used for the given type of query
-        # (:insert, :insert_select, :refresh, :update, or :delete).  True by default,
+        # (:insert, :insert_select, :update).  True by default,
         # can be overridden in other plugins to disallow prepared statements for
         # specific types of queries.
         def use_prepared_statements_for?(type)
@@ -225,16 +177,11 @@ module Sequel
           case type
           when :insert, :insert_select, :update
             true
-          # SEQUEL5: Remove :delete/:refresh
-          when :delete
-            return true unless model.fast_instance_delete_sql
-
-            # Using deletes for prepared statements appears faster on Oracle and DB2,
-            # but not for most other database types if optimized SQL is used.
-            db_type = model.db.database_type
-            db_type == :oracle || db_type == :db2
-          when :refresh
-            !model.fast_pk_lookup_sql
+          # :nocov:
+          when :delete, :refresh
+            Sequel::Deprecation.deprecate("The :delete and :refresh prepared statement types", "There should be no need to check if these types are supported")
+            false
+          # :nocov:
           else
             raise Error, "unsupported type used: #{type.inspect}"
           end

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -28,7 +28,7 @@ module Sequel
       end
 
       module ClassMethods
-        # A hash with column symbol keys and default values.  Instance's
+        # A hash with column symbol keys and default values.  Instance
         # values are merged into this hash before creating to reduce the
         # number of free columns (columns that may or may not be present
         # in the INSERT statement), as the number of prepared statements

data/lib/sequel/plugins/rcte_tree.rb

@@ -36,12 +36,12 @@ module Sequel
     #   
     #   # Eager loading - also populates the :parent and children associations
     #   # for all ancestors and descendants
-    #   Model.where(:id=>[1, 2]).eager(:ancestors, :descendants).all
+    #   Model.where(id: [1, 2]).eager(:ancestors, :descendants).all
     #   
-    #   # Eager loading children and grand children
-    #   Model.where(:id=>[1, 2]).eager(:descendants=>2).all
-    #   # Eager loading children, grand children, and great grand children
-    #   Model.where(:id=>[1, 2]).eager(:descendants=>3).all
+    #   # Eager loading children and grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 2).all
+    #   # Eager loading children, grandchildren, and great grandchildren
+    #   Model.where(id: [1, 2]).eager(descendants: 3).all
     #
     # = Options
     #
@@ -56,8 +56,8 @@ module Sequel
     # Note that you can change the name of the above associations by specifying
     # a :name key in the appropriate hash of options above.  For example:
     #
-    #   Model.plugin :rcte_tree, :parent=>{:name=>:mother},
-    #    :children=>{:name=>:daughters}, :descendants=>{:name=>:offspring}
+    #   Model.plugin :rcte_tree, parent: {name: :mother},
+    #    children: {name: :daughters}, descendants: {name: :offspring}
     #
     # Any other keys in the main options hash are treated as options shared by
     # all of the associations.  Here's a few options that affect the plugin:

data/lib/sequel/plugins/serialization.rb

@@ -2,15 +2,15 @@
 
 module Sequel
   module Plugins
-    # Sequel's built in Serialization plugin allows you to keep serialized
+    # The serialization plugin allows you to keep serialized
     # ruby objects in the database, while giving you deserialized objects
     # when you call an accessor.
     #
     # This plugin works by keeping the serialized value in the values, and
     # adding a deserialized_values hash.  The reader method for serialized columns
     # will check the deserialized_values for the value, return it if present,
-    # or deserialized the entry in values and return it.  The writer method will
-    # set the deserialized_values entry.  This plugin adds a before_save hook
+    # or deserialize the entry in values and return it.  The writer method will
+    # set the deserialized_values entry.  This plugin adds a before_validation hook
     # that serializes all deserialized_values to values.
     #
     # You can specify the serialization format as a pair of serializer/deserializer
@@ -37,9 +37,7 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse,
-    #     lambda(&:reverse),
-    #     lambda(&:reverse))
+    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -53,10 +51,10 @@ module Sequel
     #     serialize_attributes :reverse, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [lambda(&:reverse), lambda(&:reverse)], :password
+    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
     #   end
     #   user = User.create
-    #   user.permissions = { :global => 'read-only' }
+    #   user.permissions = {global: 'read-only'}
     #   user.save
     #
     # Note that if you mutate serialized column values without reassigning them,
@@ -77,7 +75,7 @@ module Sequel
       # Set up the column readers to do deserialization and the column writers
       # to save the value in deserialized_values.
       def self.apply(model, *args)
-        model.instance_eval do
+        model.instance_exec do
           @deserialization_map = {}
           @serialization_map = {}
         end
@@ -93,7 +91,7 @@ module Sequel
       # models to pick this format by name.  Both serializer and deserializer
       # should be callable objects.
       def self.register_format(format, serializer, deserializer)
-        REGISTERED_FORMATS[format] = [serializer, deserializer]
+        Sequel.synchronize{REGISTERED_FORMATS[format] = [serializer, deserializer].freeze}
       end
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
@@ -101,8 +99,8 @@ module Sequel
           v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
           Marshal.load(v)
         end)
-      register_format(:yaml, lambda(&:to_yaml), lambda{|v| YAML.load(v)})
-      register_format(:json, lambda{|v| Sequel.object_to_json(v)}, lambda{|v| Sequel.parse_json(v)})
+      register_format(:yaml, :to_yaml.to_proc, lambda{|s| YAML.load(s)})
+      register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
 
       module ClassMethods
         # A hash with column name symbols and callable values, with the value
@@ -113,15 +111,6 @@ module Sequel
         # called to serialize the column.
         attr_reader :serialization_map
 
-        def serialization_module
-          Sequel::Deprecation.deprecate('Sequel::Model.serialization_module', 'There is no replacement')
-          @serialization_module
-        end
-        def serialization_module=(v)
-          Sequel::Deprecation.deprecate('Sequel::Model.serialization_module=', 'There is no replacement')
-          @serialization_module = v
-        end
-
         Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
 
         # Freeze serialization metadata when freezing model class.
@@ -137,8 +126,8 @@ module Sequel
         # and instance level writer that stores new deserialized values.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
-            unless format = REGISTERED_FORMATS[format]
-              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{REGISTERED_FORMATS.keys.map(&:inspect).join})")
+            unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
+              raise(Error, "Unsupported serialization format: #{format} (valid formats: #{Sequel.synchronize{REGISTERED_FORMATS.keys}.map(&:inspect).join})")
             end
           end
           serializer, deserializer = format
@@ -146,13 +135,6 @@ module Sequel
           define_serialized_attribute_accessor(serializer, deserializer, *columns)
         end
         
-        # The columns that will be serialized.  This is only for
-        # backwards compatibility, use serialization_map in new code.
-        def serialized_columns
-          Sequel::Deprecation.deprecate("#{self}.serialized_columns in the serialization plugin", "Use #{self}.serialization_map.keys instead")
-          serialization_map.keys
-        end
-
         private
 
         # Add serializated attribute acessor methods to the serialization_module
@@ -198,14 +180,14 @@ module Sequel
           super
         end
 
-        private
-
         # Serialize deserialized values before saving
-        def _before_validation
+        def before_validation
           serialize_deserialized_values
           super
         end
         
+        private
+
         # Clear any cached deserialized values when doing a manual refresh.
         def _refresh_set_values(hash)
           @deserialized_values.clear if @deserialized_values

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -22,7 +22,7 @@ module Sequel
     #     plugin :serialization, :json, :permissions
     #     plugin :serialization_modification_detection
     #   end
-    #   user = User.create(:permissions => {})
+    #   user = User.create(permissions: {})
     #   user.permissions[:global] = 'read-only'
     #   user.save_changes
     module SerializationModificationDetection

data/lib/sequel/plugins/sharding.rb

@@ -5,10 +5,9 @@ module Sequel
     # The sharding plugin augments Sequel's default model sharding support
     # in the following ways:
     #
-    # * It automatically sets model instances to be saved back to the
+    # * It automatically saves model instances back to the
     #   shard they were retreived from.
-    # * It makes model associations use the same shard as the model
-    #   object.
+    # * It makes model associations use the same shard as the model object.
     # * It adds a slightly nicer API for creating model instances on
     #   specific shards.
     # 
@@ -83,11 +82,6 @@ module Sequel
           nil
         end
 
-        # Mark that associated objects should use the same server.
-        def _associated_objects_use_same_server?
-          true
-        end
-
         # Ensure that the join table for many_to_many associations uses the correct shard.
         def _join_table_dataset(opts)
           use_server(super)

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -39,11 +39,11 @@ module Sequel
     #   # Using integers to store the class type, with a :model_map hash
     #   # and an sti_key of :type
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{1=>:Staff, 2=>:Manager}
+    #     model_map: {1=>:Staff, 2=>:Manager}
     #
     #   # Using non-class name strings
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager}
     #
     #   # By default the plugin sets the respective column value
     #   # when a new instance is created.
@@ -53,22 +53,22 @@ module Sequel
     #   # You can customize this behavior with the :key_chooser option.
     #   # This is most useful when using a non-bijective mapping.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager},
-    #     :key_chooser=>proc{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger' }
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager},
+    #     key_chooser: lambda{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger'}
     #
     #   # Using custom procs, with :model_map taking column values
     #   # and yielding either a class, string, symbol, or nil, 
     #   # and :key_map taking a class object and returning the column
     #   # value to use
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>proc(&:reverse),
-    #     :key_map=>proc{|klass| klass.name.reverse}
+    #     model_map: :reverse.to_proc,
+    #     key_map: lambda{|klass| klass.name.reverse}
     #
     #   # You can use the same class for multiple values.
     #   # This is mainly useful when the sti_key column contains multiple values
     #   # which are different but do not require different code.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'staff' => "Staff",
+    #     model_map: {'staff' => "Staff",
     #                  'manager' => "Manager",
     #                  'overpayed staff' => "Staff",
     #                  'underpayed staff' => "Staff"}
@@ -80,7 +80,7 @@ module Sequel
     module SingleTableInheritance
       # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
       def self.configure(model, key, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
@@ -156,7 +156,6 @@ module Sequel
         # because of how STI works, you should not freeze an STI subclass
         # until after all subclasses of it have been created.
         def freeze
-          @sti_dataset.freeze
           @sti_key_array.freeze if @sti_key_array
           @sti_key_map.freeze if @sti_key_map.is_a?(Hash)
           @sti_model_map.freeze if @sti_model_map.is_a?(Hash)
@@ -172,7 +171,7 @@ module Sequel
           sti_subclass_added(key)
           rp = dataset.row_proc
           subclass.set_dataset(sti_subclass_dataset(key), :inherited=>true)
-          subclass.instance_eval do
+          subclass.instance_exec do
             @dataset = @dataset.with_row_proc(rp)
             @sti_key_array = key
             self.simple_table = nil
@@ -244,10 +243,8 @@ module Sequel
       end
 
       module InstanceMethods
-        private
-
         # Set the sti_key column based on the sti_key_map.
-        def _before_validation
+        def before_validation
           if new? && model.sti_key && !self[model.sti_key]
             set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end

data/lib/sequel/plugins/skip_create_refresh.rb

@@ -2,9 +2,9 @@
 
 module Sequel
   module Plugins
-    # SkipCreateRefresh is a simple plugin that make Sequel not
+    # The skip_create_refresh plugin skips the
     # refresh after saving a new model object.  Sequel does the
-    # refresh to make sure all columns are populated, which is
+    # refresh by default to make sure all columns are populated, which is
     # necessary so that database defaults work correctly.
     #
     # This plugin is mostly for performance reasons where you
@@ -12,7 +12,7 @@ module Sequel
     # but it could also help cases where records are not
     # immediately available for selection after insertion.
     #
-    # Note that Sequel does not attempt to refresh records when
+    # Note that Sequel by default does not attempt to refresh records when
     # updating existing model objects, only when inserting new
     # model objects.
     # 

data/lib/sequel/plugins/static_cache.rb

@@ -10,12 +10,12 @@ module Sequel
     # are frozen so they won't be modified unexpectedly, and before hooks disallow
     # saving or destroying instances.
     #
-    # You can use the :frozen=>false option to have this plugin return unfrozen
+    # You can use the frozen: false option to have this plugin return unfrozen
     # instances.  This is slower as it requires creating new objects, but it allows
     # you to make changes to the object and save them.  If you set the option to false,
     # you are responsible for updating the cache manually (the pg_static_cache_updater
     # extension can handle this automatically).  Note that it is not safe to use the
-    # :frozen=>false option if you are mutating column values directly.  If you are
+    # frozen: false option if you are mutating column values directly.  If you are
     # mutating column values, you should also override Model.call to dup each mutable
     # column value to ensure it is not shared by other instances.
     #
@@ -37,9 +37,9 @@ module Sequel
     #
     #   # Cache the AlbumType class statically, but return unfrozen instances
     #   # that can be modified.
-    #   AlbumType.plugin :static_cache, :frozen=>false
+    #   AlbumType.plugin :static_cache, frozen: false
     #
-    # If you would like the speed benefits of keeping :frozen=>true but still need
+    # If you would like the speed benefits of keeping frozen: true but still need
     # to occasionally update objects, you can side-step the before_ hooks by
     # overriding the class method +static_cache_allow_modifications?+ to return true:
     #
@@ -54,14 +54,13 @@ module Sequel
     # Now if you +#dup+ a Model object (the resulting object is not frozen), you
     # will be able to update and save the duplicate.
     # Note the caveats around your responsibility to update the cache still applies.
-    #
     module StaticCache
       # Populate the static caches when loading the plugin. Options:
       # :frozen :: Whether retrieved model objects are frozen.  The default is true,
       #            for better performance as the shared frozen objects can be used
       #            directly.  If set to false, new instances are created.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @static_cache_frozen = opts.fetch(:frozen, true)
           load_cache
         end
@@ -216,7 +215,7 @@ module Sequel
           @cache = h.freeze
         end
 
-        # If :frozen=>false is not used, just return the argument. Otherwise,
+        # If frozen: false is not used, just return the argument. Otherwise,
         # create a new instance with the arguments values if the argument is
         # not nil.
         def static_cache_object(o)
@@ -229,13 +228,13 @@ module Sequel
       end
 
       module InstanceMethods
-        # Disallowing destroying the object unless the :frozen=>false option was used.
+        # Disallowing destroying the object unless the frozen: false option was used.
         def before_destroy
           cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super
         end
 
-        # Disallowing saving the object unless the :frozen=>false option was used.
+        # Disallowing saving the object unless the frozen: false option was used.
         def before_save
           cancel_action("modifying model objects that use the static_cache plugin is not allowed") unless model.static_cache_allow_modifications?
           super

data/lib/sequel/plugins/string_stripper.rb

@@ -5,7 +5,7 @@ module Sequel
     # StringStripper is a plugin that strips all input strings
     # when assigning to the model's values. Example:
     #
-    #   album = Album.new(:name=>' A ')
+    #   album = Album.new(name: ' A ')
     #   album.name # => 'A'
     #
     # SQL::Blob instances and all non-strings are not modified by
@@ -14,7 +14,7 @@ module Sequel
     # other columns to skip the stripping:
     #
     #   Album.skip_string_stripping :foo
-    #   Album.new(:foo=>' A ').foo # => ' A '
+    #   Album.new(foo: ' A ').foo # => ' A '
     # 
     # Usage:
     #
@@ -28,7 +28,7 @@ module Sequel
         model.plugin(:input_transformer, :string_stripper){|v| (v.is_a?(String) && !v.is_a?(SQL::Blob)) ? v.strip : v}
       end
       def self.configure(model)
-        model.instance_eval{set_skipped_string_stripping_columns if @dataset}
+        model.instance_exec{set_skipped_string_stripping_columns if @dataset}
       end
 
       module ClassMethods

data/lib/sequel/plugins/subclasses.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The Subclasses plugin keeps track of all subclasses of the
+    # The subclasses plugin keeps track of all subclasses of the
     # current model class.  Direct subclasses are available via the
     # subclasses method, and all descendent classes are available via the
     # descendents method:

data/lib/sequel/plugins/subset_conditions.rb

@@ -14,7 +14,7 @@ module Sequel
     #
     #   # This will now create a published_conditions method
     #   Album.dataset_module do
-    #     subset :published, :published => true
+    #     subset :published, published: true
     #   end
     #
     #   Album.where(Album.published_conditions).sql
@@ -23,7 +23,7 @@ module Sequel
     #   Album.exclude(Album.published_conditions).sql
     #   # SELECT * FROM albums WHERE (published IS NOT TRUE)
     #
-    #   Album.where(Sequel.|(Album.published_conditions, :ready=>true)).sql
+    #   Album.where(Album.published_conditions | {ready: true}).sql
     #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
     module SubsetConditions
       def self.apply(mod, &block)

data/lib/sequel/plugins/table_select.rb

@@ -20,7 +20,7 @@ module Sequel
       # Modify the current model's dataset selection, if the model
       # has a dataset.
       def self.configure(model)
-        model.instance_eval do
+        model.instance_exec do
           self.dataset = dataset if @dataset
         end
       end
@@ -32,7 +32,7 @@ module Sequel
         # has no explicit selection, select table.* from that table.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join] # SEQUEL5: Only !ds.opts[:select]
+          unless ds.opts[:select]
             ds = ds.select_all(ds.first_source)
           end
           ds

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -4,7 +4,7 @@ module Sequel
   module Plugins
     # The tactical_eager_loading plugin allows you to eagerly load
     # an association for all objects retrieved from the same dataset
-    # without calling eager on the dataset.  If you attempt to load
+    # without calling +eager+ on the dataset.  If you attempt to load
     # associated objects for a record and the association for that
     # object is currently not cached, it assumes you want to get
     # the associated objects for all objects retrieved with the dataset that
@@ -40,7 +40,7 @@ module Sequel
     #
     #   # Eagerly reload all artists for these albums
     #   # SELECT * FROM artists WHERE id IN (...)
-    #   albums.first.artists(:eager_reload=>true)
+    #   albums.first.artists(eager_reload: true)
     # 
     # You can also use the :eager option to specify dependent associations
     # to eager load:
@@ -50,7 +50,7 @@ module Sequel
     #   # Eager load all artists for these albums, and all albums for those artists
     #   # SELECT * FROM artists WHERE id IN (...)
     #   # SELECT * FROM albums WHERE artist_id IN (...)
-    #   albums.first.artists(:eager=>:albums)
+    #   albums.first.artists(eager: :albums)
     #
     # You can also use :eager to specify an eager callback. For example:
     #
@@ -58,7 +58,7 @@ module Sequel
     #
     #   # Eagerly load all artists whose name starts with A-M for these albums
     #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)
-    #   albums.first.artists(:eager=>proc{|ds| ds.where(:name > 'N')})
+    #   albums.first.artists(eager: lambda{|ds| ds.where(Sequel[:name] > 'N')})
     #
     # Usage:
     #