sequel 4.11.0 → 4.12.0

data/lib/sequel/dataset/sql.rb

@@ -525,11 +525,6 @@ module Sequel
       end
     end
 
-    # REMOVE411
-    def emulated_function_sql_append(sql, f)
-      _function_sql_append(sql, native_function_name(f.f), f.args)
-    end
-
     # Append literalization of function call to SQL string.
     def function_sql_append(sql, f)
       name = f.name
@@ -827,14 +822,6 @@ module Sequel
       sql << PAREN_CLOSE
     end
 
-    # REMOVE411
-    def window_function_sql_append(sql, function, window)
-      Deprecation.deprecate("Dataset#window_function_sql_append", "Please use Sequel::SQL::Function.new(name, *args).over(...) to create an SQL window function")
-      literal_append(sql, function)
-      sql << OVER
-      literal_append(sql, window)
-    end
-
     protected
 
     # Return a from_self dataset if an order or limit is specified, so it works as expected
@@ -845,32 +832,6 @@ module Sequel
     
     private
 
-    # REMOVE411
-    def _function_sql_append(sql, name, args)
-      Deprecation.deprecate("Dataset#emulated_function_sql_append and #_function_sql_append", "Please use Sequel::SQL::Function.new!(name, args, :emulate=>true) to create an emulated SQL function")
-      case name
-      when SQL::Identifier
-        if supports_quoted_function_names?
-          literal_append(sql, name)
-        else
-          sql << name.value.to_s
-        end
-      when SQL::QualifiedIdentifier
-        if supports_quoted_function_names?
-          literal_append(sql, name)
-        else
-          sql << split_qualifiers(name).join(DOT)
-        end
-      else
-        sql << name.to_s
-      end
-      if args.empty?
-        sql << FUNCTION_EMPTY
-      else
-        literal_append(sql, args)
-      end
-    end
-
     # Formats the truncate statement.  Assumes the table given has already been
     # literalized.
     def _truncate_sql(table)

data/lib/sequel/extensions/pg_interval.rb

@@ -67,7 +67,7 @@ module Sequel
       # Creates callable objects that convert strings into ActiveSupport::Duration instances.
       class Parser
         # Regexp that parses the full range of PostgreSQL interval type output.
-        PARSER = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d\d):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/o
+        PARSER = /\A([+-]?\d+ years?\s?)?([+-]?\d+ mons?\s?)?([+-]?\d+ days?\s?)?(?:(?:([+-])?(\d{2,10}):(\d\d):(\d\d(\.\d+)?))|([+-]?\d+ hours?\s?)?([+-]?\d+ mins?\s?)?([+-]?\d+(\.\d+)? secs?\s?)?)?\z/o
 
         # Parse the interval input string into an ActiveSupport::Duration instance.
         def call(string)

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -98,15 +98,17 @@ SQL
       end
 
       # Listen on the notification channel for changes to any of tables for
-      # the models given. If notified about a change to one of the tables,
+      # the models given in a new thread. If notified about a change to one of the tables,
       # reload the cache for the related model.  Options given are also
       # passed to Database#listen.
       #
-      # Note that this implementation does not currently support model
+      # Note that this implementation does not currently support multiple
       # models that use the same underlying table.
       #
       # Options:
       # :channel_name :: Override the channel name to use.
+      # :before_thread_exit :: An object that responds to +call+ that is called before the 
+      #                        the created thread exits.
       def listen_for_static_cache_updates(models, opts=OPTS)
         raise Error, "this database object does not respond to listen, use the postgres adapter with the pg driver" unless respond_to?(:listen)
         models = [models] unless models.is_a?(Array)
@@ -119,10 +121,14 @@ SQL
         end
 
         Thread.new do
-          listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge(opts)) do |_, _, oid|
-            if model = oid_map[oid.to_i]
-              model.send(:load_cache)
+          begin
+            listen(opts[:channel_name]||default_static_cache_update_name, {:loop=>true}.merge(opts)) do |_, _, oid|
+              if model = oid_map[oid.to_i]
+                model.send(:load_cache)
+              end
             end
+          ensure
+            opts[:before_thread_exit].call if opts[:before_thread_exit]
           end
         end
       end

data/lib/sequel/model/associations.rb

@@ -248,7 +248,6 @@ module Sequel
           elsif strategy == :union
             objects = []
             ds = associated_dataset
-            ds = self[:eager_block].call(ds) if self[:eager_block]
             loader = union_eager_loader
             joiner = " UNION ALL "
             eo[:id_map].keys.each_slice(subqueries_per_union).each do |slice|
@@ -695,6 +694,7 @@ module Sequel
         def union_eager_loader
           cached_fetch(:union_eager_loader) do
             Sequel::Dataset::PlaceholderLiteralizer.loader(associated_dataset) do |pl, ds|
+              ds = self[:eager_block].call(ds) if self[:eager_block]
               keys = predicate_keys
               ds = ds.where(keys.map{pl.arg}.zip(keys))
               if eager_loading_use_associated_key?
@@ -1206,7 +1206,7 @@ module Sequel
         
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
-         cached_fetch(:select){Sequel::SQL::ColumnAll.new(associated_class.table_name)}
+          cached_fetch(:select){Sequel::SQL::ColumnAll.new(associated_class.table_name)}
         end
 
         private

data/lib/sequel/plugins/auto_validations.rb

@@ -1,13 +1,14 @@
 module Sequel
   module Plugins
-    # The auto_validations plugin automatically sets up three types of validations
+    # The auto_validations plugin automatically sets up the following types of validations
     # for your model columns:
     #
     # 1. type validations for all columns
     # 2. not_null validations on NOT NULL columns (optionally, presence validations)
     # 3. unique validations on columns or sets of columns with unique indexes
+    # 4. max length validations on string columns
     #
-    # To determine the columns to use for the not_null validations and the types for the type validations,
+    # To determine the columns to use for the type/not_null/max_length validations,
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
@@ -49,6 +50,7 @@ module Sequel
           @auto_validate_presence = false
           @auto_validate_not_null_columns = []
           @auto_validate_explicit_not_null_columns = []
+          @auto_validate_max_length_columns = []
           @auto_validate_unique_columns = []
           @auto_validate_types = true
         end
@@ -71,10 +73,14 @@ module Sequel
         # The columns with automatic not_null validations for columns present in the values.
         attr_reader :auto_validate_explicit_not_null_columns
 
+        # The columns or sets of columns with automatic max_length validations, as an array of
+        # pairs, with the first entry being the column name and second entry being the maximum length.
+        attr_reader :auto_validate_max_length_columns
+
         # The columns or sets of columns with automatic unique validations
         attr_reader :auto_validate_unique_columns
 
-        Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_unique_columns=>:dup)
+        Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_max_length_columns=>:dup, :@auto_validate_unique_columns=>:dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
 
         # Whether to use a presence validation for not null columns
@@ -91,7 +97,7 @@ module Sequel
         # If :all is given as the type, skip all auto validations.
         def skip_auto_validations(type)
           if type == :all
-            [:not_null, :types, :unique].each{|v| skip_auto_validations(v)}
+            [:not_null, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
           elsif type == :types
             @auto_validate_types = false
           else
@@ -107,6 +113,7 @@ module Sequel
           @auto_validate_not_null_columns = not_null_cols - Array(primary_key)
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
+          @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
           table = dataset.first_source_table
           @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
             db.indexes(table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns]}
@@ -134,6 +141,11 @@ module Sequel
               validates_not_null(not_null_columns, :allow_missing=>true)
             end
           end
+          unless (max_length_columns = model.auto_validate_max_length_columns).empty?
+            max_length_columns.each do |col, len|
+              validates_max_length(len, col, :allow_nil=>true)
+            end
+          end
 
           validates_schema_types if model.auto_validate_types?
 

data/lib/sequel/plugins/hook_class_methods.rb

@@ -62,7 +62,7 @@ module Sequel
         # Example of usage:
         #
         #  class MyModel
-        #   define_hook :before_move_to
+        #   add_hook_type :before_move_to
         #   before_move_to(:check_move_allowed){|o| o.allow_move?}
         #   def move_to(there)
         #     return if before_move_to == false

data/lib/sequel/plugins/nested_attributes.rb

@@ -82,29 +82,27 @@ module Sequel
         attr_accessor :nested_attributes_module
         
         # Allow nested attributes to be set for the given associations.  Options:
-        # * :destroy - Allow destruction of nested records.
-        # * :fields - If provided, should be an Array or proc. If it is an array,
-        #   restricts the fields allowed to be modified through the
-        #   association_attributes= method to the specific fields given. If it is
-        #   a proc, it will be called with the associated object and should return an
-        #   array of the allowable fields.
-        # * :limit - For *_to_many associations, a limit on the number of records
-        #   that will be processed, to prevent denial of service attacks.
-        # * :reject_if - A proc that is given each attribute hash before it is
-        #   passed to its associated object. If the proc returns a truthy
-        #   value, the attribute hash is ignored.
-        # * :remove - Allow disassociation of nested records (can remove the associated
-        #   object from the parent object, but not destroy the associated object).
-        # * :strict - Kept for backward compatibility. Setting it to false is
-        #   equivalent to setting :unmatched_pk to :ignore.
-        # * :transform - A proc to transform attribute hashes before they are
-        #   passed to associated object. Takes two arguments, the parent object and
-        #   the attribute hash. Uses the return value as the new attribute hash.
-        # * :unmatched_pk - Specify the action to be taken if a primary key is
-        #   provided in a record, but it doesn't match an existing associated
-        #   object. Set to :create to create a new object with that primary
-        #   key, :ignore to ignore the record, or :raise to raise an error.
-        #   The default is :raise.
+        # :destroy :: Allow destruction of nested records.
+        # :fields :: If provided, should be an Array or proc. If it is an array,
+        #            restricts the fields allowed to be modified through the
+        #            association_attributes= method to the specific fields given. If it is
+        #            a proc, it will be called with the associated object and should return an
+        #            array of the allowable fields.
+        # :limit :: For *_to_many associations, a limit on the number of records
+        #           that will be processed, to prevent denial of service attacks.
+        # :reject_if :: A proc that is given each attribute hash before it is
+        #               passed to its associated object. If the proc returns a truthy
+        #               value, the attribute hash is ignored.
+        # :remove :: Allow disassociation of nested records (can remove the associated
+        #            object from the parent object, but not destroy the associated object).
+        # :transform :: A proc to transform attribute hashes before they are
+        #               passed to associated object. Takes two arguments, the parent object and
+        #               the attribute hash. Uses the return value as the new attribute hash.
+        # :unmatched_pk :: Specify the action to be taken if a primary key is
+        #                  provided in a record, but it doesn't match an existing associated
+        #                  object. Set to :create to create a new object with that primary
+        #                  key, :ignore to ignore the record, or :raise to raise an error.
+        #                  The default is :raise.
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
@@ -125,25 +123,35 @@ module Sequel
         # class.
         def def_nested_attribute_method(reflection)
           nested_attributes_module.class_eval do
-            if reflection.returns_array?
-              define_method("#{reflection[:name]}_attributes=") do |array|
-                nested_attributes_list_setter(reflection, array)
-              end
-            else
-             define_method("#{reflection[:name]}_attributes=") do |h|
-                nested_attributes_setter(reflection, h)
-              end
+            define_method("#{reflection[:name]}_attributes=") do |v|
+              set_nested_attributes(reflection[:name], v)
             end
           end
         end
       end
       
       module InstanceMethods
+        # Set the nested attributes for the given association.  obj should be an enumerable of multiple objects
+        # for plural associations.  The opts hash can be used to override any of the default options set by
+        # the class-level nested_attributes call.
+        def set_nested_attributes(assoc, obj, opts=OPTS)
+          raise(Error, "no association named #{assoc} for #{model.inspect}") unless ref = model.association_reflection(assoc)
+          raise(Error, "nested attributes are not enabled for association #{assoc} for #{model.inspect}") unless meta = ref[:nested_attributes]
+          meta = meta.merge(opts)
+          meta[:reflection] = ref
+          if ref.returns_array?
+            nested_attributes_list_setter(meta, obj)
+          else
+            nested_attributes_setter(meta, obj)
+          end
+        end
+
         private
         
         # Check that the keys related to the association are not modified inside the block.  Does
         # not use an ensure block, so callers should be careful.
-        def nested_attributes_check_key_modifications(reflection, obj)
+        def nested_attributes_check_key_modifications(meta, obj)
+          reflection = meta[:reflection]
           keys = reflection.associated_object_keys.map{|x| obj.send(x)}
           yield
           unless keys == reflection.associated_object_keys.map{|x| obj.send(x)}
@@ -154,10 +162,11 @@ module Sequel
         # Create a new associated object with the given attributes, validate
         # it when the parent is validated, and save it when the object is saved.
         # Returns the object created.
-        def nested_attributes_create(reflection, attributes)
+        def nested_attributes_create(meta, attributes)
+          reflection = meta[:reflection]
           obj = reflection.associated_class.new
-          nested_attributes_set_attributes(reflection, obj, attributes)
-          after_validation_hook{validate_associated_object(reflection, obj)}
+          nested_attributes_set_attributes(meta, obj, attributes)
+          after_validation_hook{validate_associated_object(meta, obj)}
           if reflection.returns_array?
             send(reflection[:name]) << obj
             after_save_hook{send(reflection.add_method, obj)}
@@ -177,6 +186,7 @@ module Sequel
               after_save_hook{send(reflection.setter_method, obj)}
             end
           end
+          add_reciprocal_object(reflection, obj)
           obj
         end
         
@@ -184,19 +194,20 @@ module Sequel
         # If a hash is provided it, sort it by key and then use the values.
         # 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(reflection, attributes_list)
+        def nested_attributes_list_setter(meta, attributes_list)
           attributes_list = attributes_list.sort_by{|x| x.to_s}.map{|k,v| v} if attributes_list.is_a?(Hash)
-          if (limit = reflection[:nested_attributes][:limit]) && attributes_list.length > limit
+          if (limit = meta[:limit]) && attributes_list.length > limit
             raise(Error, "number of nested attributes (#{attributes_list.length}) exceeds the limit (#{limit})")
           end
-          attributes_list.each{|a| nested_attributes_setter(reflection, a)}
+          attributes_list.each{|a| nested_attributes_setter(meta, a)}
         end
         
         # Remove the given associated object from the current object. If the
         # :destroy option is given, destroy the object after disassociating it
         # (unless destroying the object would automatically disassociate it).
         # Returns the object removed.
-        def nested_attributes_remove(reflection, obj, opts=OPTS)
+        def nested_attributes_remove(meta, obj, opts=OPTS)
+          reflection = meta[:reflection]
           if !opts[:destroy] || reflection.remove_before_destroy?
             before_save_hook do
               if reflection.returns_array?
@@ -212,8 +223,8 @@ module Sequel
         
         # Set the fields in the obj based on the association, only allowing
         # specific :fields if configured.
-        def nested_attributes_set_attributes(reflection, obj, attributes)
-          if fields = reflection[:nested_attributes][:fields]
+        def nested_attributes_set_attributes(meta, obj, attributes)
+          if fields = meta[:fields]
             fields = fields.call(obj) if fields.respond_to?(:call)
             obj.set_only(attributes, fields)
           else
@@ -231,12 +242,13 @@ module Sequel
         # * If a primary key exists in the attributes hash but it does not match an associated object,
         #   either raise an error, create a new object or ignore the hash, depending on the :unmatched_pk option.
         # * If no primary key exists in the attributes hash, create a new object.
-        def nested_attributes_setter(reflection, attributes)
-          if a = reflection[:nested_attributes][:transform]
+        def nested_attributes_setter(meta, attributes)
+          if a = meta[:transform]
             attributes = a.call(self, attributes)
           end
-          return if (b = reflection[:nested_attributes][:reject_if]) && b.call(attributes)
+          return if (b = meta[:reject_if]) && b.call(attributes)
           modified!
+          reflection = meta[:reflection]
           klass = reflection.associated_class
           sym_keys = Array(klass.primary_key)
           str_keys = sym_keys.map{|k| k.to_s}
@@ -246,28 +258,28 @@ module Sequel
           end
           if obj
             attributes = attributes.dup.delete_if{|k,v| str_keys.include? k.to_s}
-            if reflection[:nested_attributes][:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
-              nested_attributes_remove(reflection, obj, :destroy=>true)
-            elsif reflection[:nested_attributes][:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
-              nested_attributes_remove(reflection, obj)
+            if meta[:destroy] && klass.db.send(:typecast_value_boolean, attributes.delete(:_delete) || attributes.delete('_delete'))
+              nested_attributes_remove(meta, obj, :destroy=>true)
+            elsif meta[:remove] && klass.db.send(:typecast_value_boolean, attributes.delete(:_remove) || attributes.delete('_remove'))
+              nested_attributes_remove(meta, obj)
             else
-              nested_attributes_update(reflection, obj, attributes)
+              nested_attributes_update(meta, obj, attributes)
             end
-          elsif pk.all? && reflection[:nested_attributes][:unmatched_pk] != :create
-            if reflection[:nested_attributes][:unmatched_pk] == :raise
+          elsif pk.all? && meta[:unmatched_pk] != :create
+            if meta[:unmatched_pk] == :raise
               raise(Error, "no matching associated object with given primary key (association: #{reflection[:name]}, pk: #{pk})")
             end
           else
-            nested_attributes_create(reflection, attributes)
+            nested_attributes_create(meta, attributes)
           end
         end
         
         # Update the given object with the attributes, validating it when the
         # parent object is validated and saving it when the parent is saved.
         # Returns the object updated.
-        def nested_attributes_update(reflection, obj, attributes)
-          nested_attributes_update_attributes(reflection, obj, attributes)
-          after_validation_hook{validate_associated_object(reflection, obj)}
+        def nested_attributes_update(meta, obj, attributes)
+          nested_attributes_update_attributes(meta, obj, attributes)
+          after_validation_hook{validate_associated_object(meta, obj)}
           # 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.
           after_save_hook{obj.save_changes(:validate=>false)}
@@ -275,15 +287,16 @@ module Sequel
         end
 
         # Update the attributes for the given object related to the current object through the association.
-        def nested_attributes_update_attributes(reflection, obj, attributes)
-          nested_attributes_check_key_modifications(reflection, obj) do
-            nested_attributes_set_attributes(reflection, obj, attributes)
+        def nested_attributes_update_attributes(meta, obj, attributes)
+          nested_attributes_check_key_modifications(meta, obj) do
+            nested_attributes_set_attributes(meta, obj, attributes)
           end
         end
 
         # Validate the given associated object, adding any validation error messages from the
         # given object to the parent object.
-        def validate_associated_object(reflection, obj)
+        def validate_associated_object(meta, obj)
+          reflection = meta[:reflection]
           return if reflection[:validate] == false
           association = reflection[:name]
           if (reflection[:type] == :one_to_many || reflection[:type] == :one_to_one) && (key = reflection[:key]).is_a?(Symbol) && !(pk_val = obj.values[key])

data/lib/sequel/plugins/prepared_statements.rb

@@ -49,6 +49,19 @@ module Sequel
 
         private
 
+        # Create a prepared statement, but modify the SQL used so that the model's columns are explicitly
+        # selected instead of using *, assuming that the dataset selects from a single table.
+        def prepare_explicit_statement(ds, type, vals=OPTS)
+          f = ds.opts[:from]
+          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)})
+          end 
+          
+          prepare_statement(ds, type, vals)
+        end
+
         # Create a prepared statement based on the given dataset with a unique name for the given
         # type of query and values.
         def prepare_statement(ds, type, vals=OPTS)
@@ -76,18 +89,18 @@ module Sequel
         # and return that column values for the row created.
         def prepared_insert_select(cols)
           if dataset.supports_insert_select?
-            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
+            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
           end
         end
 
         # Return a prepared statement that can be used to lookup a row solely based on the primary key.
         def prepared_lookup
-          cached_prepared_statement(:fixed, :lookup){prepare_statement(filter(prepared_statement_key_array(primary_key)), :first)}
+          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
-          cached_prepared_statement(:fixed, :refresh){prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)}
+          cached_prepared_statement(:fixed, :refresh){prepare_explicit_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(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
@@ -122,8 +135,6 @@ module Sequel
           prepared_lookup.call(primary_key_hash(pk))
         end
 
-        private
-
         # If a prepared statement has already been cached for the given type and subtype,
         # return it.  Otherwise, yield to the block to get the prepared statement, and cache it.
         def cached_prepared_statement(type, subtype)