sequel 3.31.0 → 3.32.0

data/lib/sequel/dataset/actions.rb

@@ -431,6 +431,10 @@ module Sequel
     #
     #   DB[:table].select_hash([:id, :foo], [:name, :bar]) # SELECT * FROM table
     #   # {[1, 3]=>['a', 'c'], [2, 4]=>['b', 'd'], ...}
+    #
+    # When using this method, you must be sure that each expression has an alias
+    # that Sequel can determine.  Usually you can do this by calling the #as method
+    # on the expression and providing an alias.
     def select_hash(key_column, value_column)
       if key_column.is_a?(Array)
         if value_column.is_a?(Array)
@@ -461,6 +465,10 @@ module Sequel
     #
     #   DB[:table].select_map([:id, :name]) # SELECT id, name FROM table
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    #
+    # If you provide an array of expressions, you must be sure that each entry
+    # in the array has an alias that Sequel can determine.  Usually you can do this
+    # by calling the #as method on the expression and providing an alias.
     def select_map(column=nil, &block)
       _select_map(column, false, &block)
     end
@@ -478,6 +486,10 @@ module Sequel
     #
     #   DB[:table].select_order_map([:id, :name]) # SELECT id, name FROM table ORDER BY id, name
     #   # => [[1, 'A'], [2, 'B'], [3, 'C'], ...]
+    #
+    # If you provide an array of expressions, you must be sure that each entry
+    # in the array has an alias that Sequel can determine.  Usually you can do this
+    # by calling the #as method on the expression and providing an alias.
     def select_order_map(column=nil, &block)
       _select_map(column, true, &block)
     end
@@ -636,17 +648,12 @@ module Sequel
     # Internals of +select_map+ and +select_order_map+
     def _select_map(column, order, &block)
       ds = naked.ungraphed
-      if column
-        raise(Error, ARG_BLOCK_ERROR_MSG) if block
-        columns = Array(column)
-        select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
-        ds = ds.select(*select_cols)
-        ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
-      else
-        ds = ds.select(&block)
-        ds = ds.order(&block) if order
-      end
-      if column.is_a?(Array)
+      columns = Array(column)
+      virtual_row_columns(columns, block)
+      select_cols = order ? columns.map{|c| c.is_a?(SQL::OrderedExpression) ? c.expression : c} : columns
+      ds = ds.select(*select_cols)
+      ds = ds.order(*columns.map{|c| unaliased_identifier(c)}) if order
+      if column.is_a?(Array) || (columns.length > 1)
         ds._select_map_multiple(select_cols.map{|c| hash_key_symbol(c)})
       else
         ds._select_map_single
@@ -694,6 +701,8 @@ module Sequel
         hash_key_symbol(s.column)
       when SQL::AliasedExpression
         hash_key_symbol(s.aliaz)
+      when String
+        s.to_sym
       else
         raise(Error, "#{s.inspect} is not supported, should be a Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression") 
       end

data/lib/sequel/dataset/mutation.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
     
     # All methods that should have a ! method added that modifies the receiver.
-    MUTATION_METHODS = QUERY_METHODS
+    MUTATION_METHODS = QUERY_METHODS - [:paginate, :naked]
     
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
@@ -39,6 +39,12 @@ module Sequel
         instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
       end
     end
+
+    # Remove the row_proc from the current dataset.
+    def naked!
+      self.row_proc = nil
+      self
+    end
     
     private
     

data/lib/sequel/dataset/prepared_statements.rb

@@ -77,6 +77,7 @@ module Sequel
       def prepared_sql
         case @prepared_type
         when :select, :all
+          # Most common scenario, so listed first.
           select_sql
         when :first
           clone(:limit=>1).select_sql
@@ -88,6 +89,8 @@ module Sequel
           update_sql(*@prepared_modify_values)
         when :delete
           delete_sql
+        else
+          select_sql
         end
       end
       
@@ -122,6 +125,7 @@ module Sequel
       def run(&block)
         case @prepared_type
         when :select, :all
+          # Most common scenario, so listed first
           all(&block)
         when :insert_select
           with_sql(prepared_sql).first
@@ -133,6 +137,13 @@ module Sequel
           update(*@prepared_modify_values)
         when :delete
           delete
+        when Array
+          case @prepared_type.at(0)
+          when :map, :to_hash
+            send(*@prepared_type, &block) 
+          end
+        else
+          all(&block)
         end
       end
       

data/lib/sequel/dataset/sql.rb

@@ -419,14 +419,10 @@ module Sequel
           val_array = true
           empty_val_array = vals == []
         end
-        if col_array
-          if empty_val_array
-            if op == :IN
-              literal_append(sql, SQL::BooleanExpression.from_value_pairs(cols.to_a.map{|x| [x, x]}, :AND, true))
-            else
-              literal_append(sql, 1=>1)
-            end
-          elsif !supports_multiple_column_in?
+        if empty_val_array
+          literal_append(sql, empty_array_value(op, cols))
+        elsif col_array
+          if !supports_multiple_column_in?
             if val_array
               expr = SQL::BooleanExpression.new(:OR, *vals.to_a.map{|vs| SQL::BooleanExpression.from_value_pairs(cols.to_a.zip(vs).map{|c, v| [c, v]})})
               literal_append(sql, op == :IN ? expr : ~expr)
@@ -452,19 +448,11 @@ module Sequel
             sql << PAREN_CLOSE
           end
         else
-          if empty_val_array
-            if op == :IN
-              literal_append(sql, SQL::BooleanExpression.from_value_pairs([[cols, cols]], :AND, true))
-            else
-              literal_append(sql, 1=>1)
-            end
-          else
-            sql << PAREN_OPEN
-            literal_append(sql, cols)
-            sql << SPACE << op.to_s << SPACE
-            literal_append(sql, vals)
-            sql << PAREN_CLOSE
-          end
+          sql << PAREN_OPEN
+          literal_append(sql, cols)
+          sql << SPACE << op.to_s << SPACE
+          literal_append(sql, vals)
+          sql << PAREN_CLOSE
         end
       when *TWO_ARITY_OPERATORS
         sql << PAREN_OPEN
@@ -856,6 +844,11 @@ module Sequel
       :"#{DATASET_ALIAS_BASE_NAME}#{number}"
     end
     
+    # The strftime format to use when literalizing the time.
+    def default_timestamp_format
+      requires_sql_standard_datetimes? ? STANDARD_TIMESTAMP_FORMAT : TIMESTAMP_FORMAT
+    end
+
     # The order of methods to call to build the DELETE SQL statement
     def delete_clause_methods
       DELETE_CLAUSE_METHODS
@@ -877,9 +870,13 @@ module Sequel
       end
     end
     
-    # The strftime format to use when literalizing the time.
-    def default_timestamp_format
-      requires_sql_standard_datetimes? ? STANDARD_TIMESTAMP_FORMAT : TIMESTAMP_FORMAT
+    def empty_array_value(op, cols)
+      if Sequel.empty_array_handle_nulls
+        c = Array(cols)
+        SQL::BooleanExpression.from_value_pairs(c.zip(c), :AND, op == :IN)
+      else
+        {1 => ((op == :IN) ? 0 : 1)}
+      end
     end
     
     # Format the timestamp based on the default_timestamp_format, with a couple

data/lib/sequel/extensions/query.rb

@@ -43,7 +43,7 @@ module Sequel
 
       # Merge the given options into the receiver's options and return the receiver
       # instead of cloning the receiver.
-      def clone(opts = nil)
+      def clone(opts = {})
         @opts.merge!(opts)
         self
       end

data/lib/sequel/model.rb

@@ -70,7 +70,8 @@ module Sequel
     EMPTY_INSTANCE_VARIABLES = [:@overridable_methods_module, :@db]
 
     # Boolean settings that can be modified at the global, class, or instance level.
-    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_transactions]
+    BOOLEAN_SETTINGS = [:typecast_empty_string_to_nil, :typecast_on_assignment, :strict_param_setting, \
+      :raise_on_save_failure, :raise_on_typecast_failure, :require_modification, :use_after_commit_rollback, :use_transactions]
 
     # Hooks that are called before an action.  Can return false to not do the action.  When
     # overriding these, it is recommended to call +super+ as the last line of your method,
@@ -103,7 +104,8 @@ module Sequel
       :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@simple_pk=>nil, :@simple_table=>nil, :@strict_param_setting=>nil,
       :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil,
-      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil}
+      :@raise_on_typecast_failure=>nil, :@plugins=>:dup, :@setter_methods=>nil,
+      :@use_after_commit_rollback=>nil}
 
     # Regular expression that determines if a method name is normal in the sense that
     # it could be used literally in ruby code without using send.  Used to
@@ -133,6 +135,7 @@ module Sequel
     @strict_param_setting = true
     @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
+    @use_after_commit_rollback = true
     @use_transactions = true
 
     Sequel.require %w"default_inflections inflections plugins base exceptions errors", "model"

data/lib/sequel/model/associations.rb

@@ -268,6 +268,18 @@ module Sequel
         end
         alias associated_object_keys primary_keys
 
+        # The method symbol or array of method symbols to call on the associated object
+        # to get the value to use for the foreign keys.
+        def primary_key_method
+         self[:primary_key_method] ||= primary_key
+        end
+       
+        # The array of method symbols to call on the associated object
+        # to get the value to use for the foreign keys.
+        def primary_key_methods
+         self[:primary_key_methods] ||= Array(primary_key_method)
+        end
+       
         # #primary_key qualified by the associated table
         def qualified_primary_key
           self[:qualified_primary_key] ||= self[:qualify] == false ? primary_key : qualify_assoc(primary_key)
@@ -528,6 +540,18 @@ module Sequel
           self[:right_primary_keys] ||= Array(right_primary_key)
         end
     
+        # The method symbol or array of method symbols to call on the associated objects
+        # to get the foreign key values for the join table. 
+        def right_primary_key_method
+          self[:right_primary_key_method] ||= right_primary_key
+        end
+
+        # The array of method symbols to call on the associated objects
+        # to get the foreign key values for the join table. 
+        def right_primary_key_methods
+          self[:right_primary_key_methods] ||= Array(right_primary_key_method)
+        end
+        
         # The columns to select when loading the association, associated_class.table_name.* by default.
         def select
          return self[:select] if include?(:select)
@@ -763,11 +787,13 @@ module Sequel
         #         array of symbols for a composite key association.
         # :key_column :: Similar to, and usually identical to, :key, but :key refers to the model method
         #                to call, where :key_column refers to the underlying column.  Should only be
-        #                used if the association has the same name as the foreign key column, in conjunction
+        #                used if the the model method differs from the foreign key column, in conjunction
         #                with defining a model alias method for the key column.
         # :primary_key :: column in the associated table that :key option references, as a symbol.
         #                 Defaults to the primary key of the associated table. Can use an
         #                 array of symbols for a composite key association.
+        # :primary_key_method :: the method symbol or array of method symbols to call on the associated
+        #                        object to get the foreign key values.  Defaults to :primary_key option.
         # :qualify :: Whether to use qualifier primary keys when loading the association.  The default
         #             is true, so you must set to false to not qualify.  Qualification rarely causes
         #             problems, but it's necessary to disable in some cases, such as when you are doing
@@ -777,9 +803,15 @@ module Sequel
         #         current model's primary key, as a symbol.  Defaults to
         #         :"#{self.name.underscore}_id".  Can use an
         #         array of symbols for a composite key association.
+        # :key_method :: the method symbol or array of method symbols to call on the associated
+        #                object to get the foreign key values.  Defaults to :key option.
         # :primary_key :: column in the current table that :key option references, as a symbol.
         #                 Defaults to primary key of the current table. Can use an
         #                 array of symbols for a composite key association.
+        # :primary_key_column :: Similar to, and usually identical to, :primary_key, but :primary_key refers
+        #                to the model method call, where :primary_key_column refers to the underlying column.
+        #                Should only be used if the the model method differs from the primary key column, in
+        #                conjunction with defining a model alias method for the primary key column.
         # === :many_to_many
         # :graph_join_table_block :: The block to pass to +join_table+ for
         #                            the join table when eagerly loading the association via +eager_graph+.
@@ -806,12 +838,19 @@ module Sequel
         # :left_primary_key :: column in current table that :left_key points to, as a symbol.
         #                      Defaults to primary key of current table.  Can use an
         #                      array of symbols for a composite key association.
+        # :left_primary_key_column :: Similar to, and usually identical to, :left_primary_key, but :left_primary_key refers to
+        #                the model method to call, where :left_primary_key_column refers to the underlying column.  Should only
+        #                be used if the model method differs from the left primary key column, in conjunction
+        #                with defining a model alias method for the left primary key column.
         # :right_key :: foreign key in join table that points to associated
         #               model's primary key, as a symbol.  Defaults to Defaults to :"#{name.to_s.singularize}_id".
         #               Can use an array of symbols for a composite key association.
         # :right_primary_key :: column in associated table that :right_key points to, as a symbol.
         #                       Defaults to primary key of the associated table.  Can use an
         #                       array of symbols for a composite key association.
+        # :right_primary_key_method :: the method symbol or array of method symbols to call on the associated
+        #                              object to get the foreign key values for the join table.
+        #                              Defaults to :right_primary_key option.
         # :uniq :: Adds a after_load callback that makes the array of objects unique.
         def associate(type, name, opts = {}, &block)
           raise(Error, 'one_to_many association type with :one_to_one option removed, used one_to_one association type') if opts[:one_to_one] && type == :one_to_many
@@ -1034,6 +1073,9 @@ module Sequel
           rcks = opts[:right_keys] = Array(right)
           left_pk = (opts[:left_primary_key] ||= self.primary_key)
           lcpks = opts[:left_primary_keys] = Array(left_pk)
+          lpkc = opts[:left_primary_key_column] ||= left_pk
+          lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
+          elk = opts.eager_loader_key
           raise(Error, "mismatched number of left composite keys: #{lcks.inspect} vs #{lcpks.inspect}") unless lcks.length == lcpks.length
           if opts[:right_primary_key]
             rcpks = Array(opts[:right_primary_key])
@@ -1050,7 +1092,7 @@ module Sequel
           opts[:dataset] ||= proc{opts.associated_class.inner_join(join_table, rcks.zip(opts.right_primary_keys) + lcks.zip(lcpks.map{|k| send(k)}))}
 
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][left_pk]
+            h = eo[:key_hash][elk]
             rows = eo[:rows]
             rows.each{|object| object.associations[name] = []}
             r = rcks.zip(opts.right_primary_keys)
@@ -1095,7 +1137,7 @@ module Sequel
           jt_graph_block = opts[:graph_join_table_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lcpks) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
+            ds = ds.graph(join_table, use_jt_only_conditions ? jt_only_conditions : lcks.zip(lpkcs) + graph_jt_conds, :select=>false, :table_alias=>ds.unused_table_alias(join_table, [eo[:table_alias]]), :join_type=>jt_join_type, :implicit_qualifier=>eo[:implicit_qualifier], :from_self_alias=>ds.opts[:eager_graph][:master], &jt_graph_block)
             ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : opts.right_primary_keys.zip(rcks) + conditions, :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
       
@@ -1106,11 +1148,11 @@ module Sequel
           association_module_private_def(opts._add_method, opts) do |o|
             h = {}
             lcks.zip(lcpks).each{|k, pk| h[k] = send(pk)}
-            rcks.zip(opts.right_primary_keys).each{|k, pk| h[k] = o.send(pk)}
+            rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.send(pk)}
             _join_table_dataset(opts).insert(h)
           end
           association_module_private_def(opts._remove_method, opts) do |o|
-            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_keys.map{|k| o.send(k)})).delete
+            _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.send(k)})).delete
           end
           association_module_private_def(opts._remove_all_method, opts) do
             _join_table_dataset(opts).filter(lcks.zip(lcpks.map{|k| send(k)})).delete
@@ -1154,7 +1196,7 @@ module Sequel
             unless keys.empty?
               klass = opts.associated_class
               model.eager_loading_dataset(opts, klass.filter(opts.qualified_primary_key=>keys), nil, eo[:associations], eo).all do |assoc_record|
-                hash_key = uses_cks ? opts.primary_keys.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key)
+                hash_key = uses_cks ? opts.primary_key_methods.map{|k| assoc_record.send(k)} : assoc_record.send(opts.primary_key_method)
                 next unless objects = h[hash_key]
                 objects.each{|object| object.associations[name] = assoc_record}
               end
@@ -1177,7 +1219,7 @@ module Sequel
           
           return if opts[:read_only]
       
-          association_module_private_def(opts._setter_method, opts){|o| cks.zip(opts.primary_keys).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
+          association_module_private_def(opts._setter_method, opts){|o| cks.zip(opts.primary_key_methods).each{|k, pk| send(:"#{k}=", (o.send(pk) if o))}}
           association_module_def(opts.setter_method, opts){|o| set_associated_object(opts, o)}
         end
         
@@ -1187,16 +1229,20 @@ module Sequel
           name = opts[:name]
           model = self
           key = (opts[:key] ||= opts.default_key)
+          km = opts[:key_method] ||= opts[:key]
           cks = opts[:keys] = Array(key)
           primary_key = (opts[:primary_key] ||= self.primary_key)
           cpks = opts[:primary_keys] = Array(primary_key)
+          pkc = opts[:primary_key_column] ||= primary_key
+          pkcs = opts[:primary_key_columns] ||= Array(pkc)
+          elk = opts.eager_loader_key
           raise(Error, "mismatched number of composite keys: #{cks.inspect} vs #{cpks.inspect}") unless cks.length == cpks.length
           uses_cks = opts[:uses_composite_keys] = cks.length > 1
           opts[:dataset] ||= proc do
             opts.associated_class.filter(Array(opts.qualified_key).zip(cpks.map{|k| send(k)}))
           end
           opts[:eager_loader] ||= proc do |eo|
-            h = eo[:key_hash][primary_key]
+            h = eo[:key_hash][elk]
             rows = eo[:rows]
             if one_to_one
               rows.each{|object| object.associations[name] = nil}
@@ -1221,7 +1267,7 @@ module Sequel
             end
             ds.all do |assoc_record|
               assoc_record.values.delete(rn) if delete_rn
-              hash_key = uses_cks ? cks.map{|k| assoc_record.send(k)} : assoc_record.send(key)
+              hash_key = uses_cks ? km.map{|k| assoc_record.send(k)} : assoc_record.send(km)
               next unless objects = h[hash_key]
               if one_to_one
                 objects.each do |object| 
@@ -1252,7 +1298,7 @@ module Sequel
           graph_block = opts[:graph_block]
           opts[:eager_grapher] ||= proc do |eo|
             ds = eo[:self]
-            ds = ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : cks.zip(cpks) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
+            ds = ds.graph(eager_graph_dataset(opts, eo), use_only_conditions ? only_conditions : cks.zip(pkcs) + conditions, eo.merge(:select=>select, :join_type=>join_type, :from_self_alias=>ds.opts[:eager_graph][:master]), &graph_block)
             # We only load reciprocals for one_to_many associations, as other reciprocals don't make sense
             ds.opts[:eager_graph][:reciprocals][eo[:table_alias]] = opts.reciprocal
             ds
@@ -1939,25 +1985,33 @@ module Sequel
         # Return a subquery expression for filering by a many_to_many association
         def many_to_many_association_filter_expression(op, ref, obj)
           lpks, lks, rks = ref.values_at(:left_primary_keys, :left_keys, :right_keys)
+          jt = ref.join_table_alias
           lpks = lpks.first if lpks.length == 1
-          exp = association_filter_key_expression(rks, ref.right_primary_keys, obj)
+          lpks = ref.qualify(model.table_name, lpks)
+          meths = ref.right_primary_keys
+          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          exp = association_filter_key_expression(ref.qualify(jt, rks), meths, obj)
           if exp == SQL::Constants::FALSE
             association_filter_handle_inversion(op, exp, Array(lpks))
           else
-            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db.from(ref[:join_table]).select(*lks).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(lks.zip([]), :OR))), Array(lpks))
+            association_filter_handle_inversion(op, SQL::BooleanExpression.from_value_pairs(lpks=>model.db.from(ref[:join_table]).select(*ref.qualify(jt, lks)).where(exp).exclude(SQL::BooleanExpression.from_value_pairs(ref.qualify(jt, lks).zip([]), :OR))), Array(lpks))
           end
         end
 
         # Return a simple equality expression for filering by a many_to_one association
         def many_to_one_association_filter_expression(op, ref, obj)
-          keys = ref[:keys]
-          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref.primary_keys, obj), keys)
+          keys = ref.qualify(model.table_name, ref[:keys])
+          meths = ref.primary_keys
+          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, meths, obj), keys)
         end
 
         # Return a simple equality expression for filering by a one_to_* association
         def one_to_many_association_filter_expression(op, ref, obj)
-          keys = ref[:primary_keys]
-          association_filter_handle_inversion(op, association_filter_key_expression(keys, ref[:keys], obj), keys)
+          keys = ref.qualify(model.table_name, ref[:primary_keys])
+          meths = ref[:keys]
+          meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
+          association_filter_handle_inversion(op, association_filter_key_expression(keys, meths, obj), keys)
         end
         alias one_to_one_association_filter_expression one_to_many_association_filter_expression