sequel 4.49.0 → 5.0.0

data/lib/sequel/plugins/many_through_many.rb

@@ -46,18 +46,18 @@ module Sequel
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]]
     #
     #   # All albums by artists that are associated to any album that this artist is associated to
-    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id], \
-    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]], \
-    #    :class=>:Album
+    #   Artist.many_through_many :artist_albums, [[:albums_artists, :artist_id, :album_id],
+    #    [:albums_artists, :album_id, :artist_id], [:albums_artists, :artist_id, :album_id]],
+    #    class: :Album
     #
     #   # All tracks on albums by this artist (also could be a many_to_many)
-    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]], \
-    #    :right_primary_key=>:album_id
+    #   Artist.many_through_many :tracks, [[:albums_artists, :artist_id, :album_id]],
+    #    right_primary_key: :album_id
     #
     # Often you don't want the current object to appear in the array of associated objects.  This is easiest to handle via an :after_load hook:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums_artists, :album_id, :artist_id]],
-    #     :after_load=>proc{|artist, associated_artists| associated_artists.delete(artist)}
+    #     after_load: lambda{|artist, associated_artists| associated_artists.delete(artist)}
     #
     # You can also handle it by adding a dataset block that excludes the current record (so it won't be retrieved at all), but
     # that won't work when eagerly loading, which is why the :after_load proc is recommended instead.
@@ -65,7 +65,7 @@ module Sequel
     # It's also common to not want duplicate records, in which case the :distinct option can be used:
     # 
     #   Artist.many_through_many :artists, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id]],
-    #    :distinct=>true
+    #    distinct: true
     # 
     # In addition to many_through_many, this plugin also adds one_through_many, for an association to a single object through multiple join tables.
     # This is useful if there are unique constraints on the foreign keys in the join tables that reference back to the current table, or if you want
@@ -228,7 +228,10 @@ module Sequel
         def def_many_through_many(opts)
           one_through_many = opts[:type] == :one_through_many
           opts[:read_only] = true
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:cartesian_product_number] ||= one_through_many ? 0 : 2
           opts[:through] = opts[:through].map do |e|
             case e

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -12,15 +12,15 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::NoExistingObject
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::NoExistingObject
     #
     # In order for this plugin to work, you need to make sure that the database
     # table has a column of timestamp or rowversion.  The plugin uses a default
     # name of timestamp for this columns, but you can override that using the
     # :lock_column option:
     #
-    #     plugin :mssql_optimistic_locking, :lock_column=>:column_name
+    #     plugin :mssql_optimistic_locking, lock_column: :column_name
     #
     # This plugin relies on the instance_filters plugin.
     module MssqlOptimisticLocking

data/lib/sequel/plugins/nested_attributes.rb

@@ -13,11 +13,11 @@ module Sequel
     # The nested_attributes call defines a single method, <tt><i>association</i>_attributes=</tt>,
     # (e.g. <tt>albums_attributes=</tt>).  So if you have an Artist instance:
     #
-    #   a = Artist.new(:name=>'YJM')
+    #   a = Artist.new(name: 'YJM')
     #
     # You can create new album instances related to this artist:
     #
-    #   a.albums_attributes = [{:name=>'RF'}, {:name=>'MO'}]
+    #   a.albums_attributes = [{name: 'RF'}, {name: 'MO'}]
     #
     # Note that this doesn't send any queries to the database yet.  That doesn't happen till
     # you save the object:
@@ -33,7 +33,7 @@ module Sequel
     # objects.  You just need to make sure that the primary key field is filled in for the
     # associated object:
     #
-    #   a.update(:albums_attributes => [{:id=>1, :name=>'T'}])
+    #   a.update(:albums_attributes => [{id: 1, name: 'T'}])
     #
     # Since the primary key field is filled in, the plugin will update the album with id 1 instead
     # of creating a new album.
@@ -41,15 +41,15 @@ module Sequel
     # If you would like to delete the associated object instead of updating it, you add a _delete
     # entry to the hash, and also pass the :destroy option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :destroy=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_delete=>true}])
+    #   Artist.nested_attributes :albums, destroy: true
+    #   a.update(:albums_attributes => [{id: 1, _delete: true}])
     #
     # This will delete the related associated object from the database.  If you want to leave the
     # associated object in the database, but just remove it from the association, add a _remove
     # entry in the hash, and also pass the :remove option when calling +nested_attributes+:
     #
-    #   Artist.nested_attributes :albums, :remove=>true
-    #   a.update(:albums_attributes => [{:id=>1, :_remove=>true}])
+    #   Artist.nested_attributes :albums, remove: true
+    #   a.update(:albums_attributes => [{id: 1, _remove: true}])
     #
     # The above example was for a one_to_many association, but the plugin also works similarly
     # for other association types.  For one_to_one and many_to_one associations, you need to
@@ -66,11 +66,11 @@ module Sequel
     #
     # Your web stack will probably parse that into a nested hash similar to:
     #
-    #   {:artist=>{:name=>'Y', :albums_attributes=>{0=>{:name=>'X'}, 1=>{:id=>'2', :name=>'Z'}}}}
+    #   {'artist'=>{'name'=>'Y', 'albums_attributes'=>{'0'=>{'name'=>'X'}, '1'=>{'id'=>'2', 'name'=>'Z'}}}}
     #
     # Then you can do:
     #
-    #   artist.update_fields(params[:artist], [:name, :albums_artists])
+    #   artist.update_fields(params['artist'], %w'name albums_artists')
     #
     # To save changes to the artist, create the first album and associate it to the artist,
     # and update the other existing associated album.
@@ -81,15 +81,6 @@ module Sequel
       end
       
       module ClassMethods
-        def nested_attributes_module
-          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module', 'There is no replacement')
-          @nested_attributes_module
-        end
-        def nested_attributes_module=(v)
-          Sequel::Deprecation.deprecate('Sequel::Model.nested_attributes_module=', 'There is no replacement')
-          @nested_attributes_module = v
-        end
-        
         # Freeze nested_attributes_module when freezing model class.
         def freeze
           @nested_attributes_module.freeze if @nested_attributes_module
@@ -127,11 +118,7 @@ module Sequel
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
             r[:nested_attributes] = opts
-            r[:nested_attributes][:unmatched_pk] ||= (
-              if opts.has_key?(:strict)
-                Sequel::Deprecation.deprecate("The nested_attributes :strict option", "Use the :unmatched_pk option instead")
-              end
-              opts.delete(:strict) == false ? :ignore : :raise)
+            r[:nested_attributes][:unmatched_pk] ||= :raise
             r[:nested_attributes][:reject_if] ||= block
             def_nested_attribute_method(r)
           end
@@ -188,8 +175,8 @@ module Sequel
           nested_attributes_set_attributes(meta, obj, attributes)
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
-            send(reflection[:name]) << obj
-            after_save_hook{send(reflection.add_method, obj)}
+            public_send(reflection[:name]) << obj
+            after_save_hook{public_send(reflection[:add_method], obj)}
           else
             associations[reflection[:name]] = obj
 
@@ -201,9 +188,9 @@ module Sequel
             # Don't need to validate the object twice if :validate association option is not false
             # and don't want to validate it at all if it is false.
             if reflection[:type] == :many_to_one 
-              before_save_hook{send(reflection.setter_method, obj.save(:validate=>false))}
+              before_save_hook{public_send(reflection[:setter_method], obj.save(:validate=>false))}
             else
-              after_save_hook{send(reflection.setter_method, obj)}
+              after_save_hook{public_send(reflection[:setter_method], obj)}
             end
           end
           add_reciprocal_object(reflection, obj)
@@ -215,7 +202,7 @@ module Sequel
         # If there is a limit on the nested attributes for this association,
         # make sure the length of the attributes_list is not greater than the limit.
         def nested_attributes_list_setter(meta, attributes_list)
-          attributes_list = attributes_list.sort_by(&:to_s).map{|k,v| v} if attributes_list.is_a?(Hash)
+          attributes_list = attributes_list.sort.map{|k,v| v} if attributes_list.is_a?(Hash)
           if (limit = meta[:limit]) && attributes_list.length > limit
             raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
           end
@@ -231,9 +218,9 @@ module Sequel
           if !opts[:destroy] || reflection.remove_before_destroy?
             before_save_hook do
               if reflection.returns_array?
-                send(reflection.remove_method, obj)
+                public_send(reflection[:remove_method], obj)
               else
-                send(reflection.setter_method, nil)
+                public_send(reflection[:setter_method], nil)
               end
             end
           end
@@ -277,7 +264,7 @@ module Sequel
           str_keys = sym_keys.map(&:to_s)
           if (pk = attributes.values_at(*sym_keys)).all? || (pk = attributes.values_at(*str_keys)).all?
             pk = pk.map(&:to_s)
-            obj = Array(send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
+            obj = Array(public_send(reflection[:name])).find{|x| Array(x.pk).map(&:to_s) == pk}
           end
           if obj
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}

data/lib/sequel/plugins/optimistic_locking.rb

@@ -11,11 +11,11 @@ module Sequel
     #   end
     #   p1 = Person[1]
     #   p2 = Person[1]
-    #   p1.update(:name=>'Jim') # works
-    #   p2.update(:name=>'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
+    #   p1.update(name: 'Jim') # works
+    #   p2.update(name: 'Bob') # raises Sequel::Plugins::OptimisticLocking::Error
     #
     # In order for this plugin to work, you need to make sure that the database
-    # table has a lock_version column (or other column you name via the lock_column
+    # table has a +lock_version+ column (or other column you name via the lock_column
     # class level accessor) that defaults to 0.
     #
     # This plugin relies on the instance_filters plugin.

data/lib/sequel/plugins/pg_array_associations.rb

@@ -328,7 +328,10 @@ module Sequel
           opts[:key] = opts.default_key unless opts.has_key?(:key)
           key = opts[:key]
           key_column = opts[:key_column] ||= opts[:key]
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(Sequel.pg_array_op(opts.predicate_key).contains(Sequel.pg_array([get_column_value(pk)], opts.array_type)))
           end
@@ -408,7 +411,10 @@ module Sequel
           key = opts[:key]
           key_column = opts[:key_column] ||= key
           opts[:eager_loader_key] = nil
-          opts[:after_load].unshift(:array_uniq!) if opts[:uniq]
+          if opts[:uniq]
+            opts[:after_load] ||= []
+            opts[:after_load].unshift(:array_uniq!)
+          end
           opts[:dataset] ||= lambda do
             opts.associated_dataset.where(opts.predicate_key=>get_column_value(key).to_a)
           end

data/lib/sequel/plugins/pg_row.rb

@@ -41,22 +41,13 @@ module Sequel
     #
     #   Address.register_row_type
     #
-    # Note that automatic conversion only works with the native postgres adapter.
-    # For other adapters that connect to PostgreSQL, you need to call the conversion
-    # proc manually.
-    #
     # In addition to returning row-valued/composite types as instances of Sequel::Model,
     # this also lets you use model instances in datasets when inserting, updating, and
     # filtering:
     #
-    #   DB[:company].insert(:name=>'MS', :address=>
-    #     Address.load(:street=>'123 Foo St', :city=>'Bar Town', :zip=>'12345'))
+    #   DB[:company].insert(name: 'MS', address:
+    #     Address.load(street: '123 Foo St', city: 'Bar Town', zip: '12345'))
     module PgRow
-      ROW = 'ROW'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :ROW)
-      CAST = '::'.freeze
-      Sequel::Deprecation.deprecate_constant(self, :CAST)
-
       # When loading the extension, make sure the database has the pg_row extension
       # loaded, load the custom database extensions, and automatically register the
       # row type if the model has a dataset.

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: