sequel 3.40.0 → 3.41.0

data/lib/sequel/extensions/pg_array.rb

@@ -99,6 +99,8 @@ module Sequel
   module Postgres
     # Represents a PostgreSQL array column value.
     class PGArray < DelegateClass(Array)
+      include Sequel::SQL::AliasMethods
+
       ARRAY = "ARRAY".freeze
       DOUBLE_COLON = '::'.freeze
       EMPTY_BRACKET = '[]'.freeze

data/lib/sequel/extensions/pg_hstore.rb

@@ -86,6 +86,8 @@ require 'strscan'
 module Sequel
   module Postgres
     class HStore < DelegateClass(Hash)
+      include Sequel::SQL::AliasMethods
+
       # Parser for PostgreSQL hstore output format.
       class Parser < StringScanner
         QUOTE_RE = /"/.freeze

data/lib/sequel/extensions/pg_json.rb

@@ -63,6 +63,8 @@ module Sequel
 
     # Class representating PostgreSQL JSON column array values.
     class JSONArray < DelegateClass(Array)
+      include Sequel::SQL::AliasMethods
+
       # Convert the array to a string using to_json, append a
       # literalized version of the string to the sql, and explicitly
       # cast the string to json.
@@ -74,6 +76,8 @@ module Sequel
 
     # Class representating PostgreSQL JSON column hash/object values.
     class JSONHash < DelegateClass(Hash)
+      include Sequel::SQL::AliasMethods
+
       # Convert the array to a string using to_json, append a
       # literalized version of the string to the sql, and explicitly
       # cast the string to json.

data/lib/sequel/extensions/pg_range.rb

@@ -59,6 +59,7 @@ Sequel.require 'adapters/utils/pg_types'
 module Sequel
   module Postgres
     class PGRange
+      include Sequel::SQL::AliasMethods
 
       # Map of string database type names to type symbols (e.g. 'int4range' => :int4range),
       # used in the schema parsing.

data/lib/sequel/extensions/pg_row.rb

@@ -81,6 +81,8 @@ module Sequel
       # this is only used for generic PostgreSQL record types, as registered
       # types use HashRow by default.
       class ArrayRow < DelegateClass(Array)
+        include Sequel::SQL::AliasMethods
+
         class << self
           # The database type for this class.  May be nil if this class
           # done not have a specific database type.
@@ -125,6 +127,8 @@ module Sequel
       # Types registered via Database#register_row_type will use this
       # class by default.
       class HashRow < DelegateClass(Hash)
+        include Sequel::SQL::AliasMethods
+
         class << self
           # The columns associated with this class.
           attr_accessor :columns

data/lib/sequel/plugins/prepared_statements.rb

@@ -11,7 +11,8 @@ module Sequel
     # of prepared statements that can be created, unless you tightly control how your
     # model instances are saved.
     # 
-    # This plugin probably does not work correctly with the instance filters plugin.
+    # This plugin does not work correctly with the instance filters plugin
+    # or the update_primary_key plugin.
     # 
     # Usage:
     #

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -35,6 +35,17 @@ module Sequel
     #   Employee.plugin :single_table_inheritance, :type,
     #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
     #
+    #   # By default the plugin sets the respective column value
+    #   # when a new instance is created.
+    #   Staff.create.type == 'line staff'
+    #   Manager.create.type == 'supervisor'
+    #
+    #   # 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' }
+    #
     #   # 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
@@ -43,6 +54,15 @@ module Sequel
     #     :model_map=>proc{|v| v.reverse},
     #     :key_map=>proc{|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",
+    #                  'manager => "Manager",
+    #                  'overpayed staff => "Staff",
+    #                  'underpayed staff' => "Staff"}
+    #
     # One minor issue to note is that if you specify the <tt>:key_map</tt>
     # option as a hash, instead of having it inferred from the <tt>:model_map</tt>,
     # you should only use class name strings as keys, you should not use symbols
@@ -57,20 +77,38 @@ module Sequel
           @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
           @sti_key_map = if km = opts[:key_map]
             if km.is_a?(Hash)
-              h = Hash.new{|h,k| h[k.to_s] unless k.is_a?(String)}
-              h.merge!(km)
+              h = Hash.new do |h,k| 
+                unless k.is_a?(String)
+                  h[k.to_s]
+                else
+                  []
+                end
+              end
+              km.each do |k,v|
+                h[k.to_s] = [ ] unless h.key?(k.to_s)
+                h[k.to_s].push( *Array(v) )
+              end
+              h
             else
               km
             end
           elsif sti_model_map.is_a?(Hash)
-            h = Hash.new{|h,k| h[k.to_s] unless k.is_a?(String)}
+            h = Hash.new do |h,k| 
+              unless k.is_a?(String)
+                h[k.to_s]
+              else
+                []
+              end
+            end
             sti_model_map.each do |k,v|
-              h[v.to_s] = k
+              h[v.to_s] = [ ] unless h.key?(v.to_s)
+              h[v.to_s] << k
             end
             h
           else
             lambda{|klass| klass.name.to_s}
           end
+          @sti_key_chooser = opts[:key_chooser] || lambda{|inst| Array(inst.model.sti_key_map[inst.model]).last }
           dataset.row_proc = lambda{|r| model.sti_load(r)}
         end
       end
@@ -97,6 +135,10 @@ module Sequel
         # the value of the sti_key column to the appropriate class to use.
         attr_reader :sti_model_map
 
+        # A proc which returns the value to use for new instances.
+        # This defaults to a lookup in the key map.
+        attr_reader :sti_key_chooser
+
         # Copy the necessary attributes to the subclasses, and filter the
         # subclass's dataset based on the sti_kep_map entry for the class.
         def inherited(subclass)
@@ -105,18 +147,19 @@ module Sequel
           sd = sti_dataset
           skm = sti_key_map
           smm = sti_model_map
-          key = skm[subclass] 
+          skc = sti_key_chooser
+          key = Array(skm[subclass]).dup
           sti_subclass_added(key)
-          ska = [key]
           rp = dataset.row_proc
-          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>ska), :inherited=>true)
+          subclass.set_dataset(sd.filter(SQL::QualifiedIdentifier.new(table_name, sk)=>key), :inherited=>true)
           subclass.instance_eval do
             dataset.row_proc = rp
             @sti_key = sk
-            @sti_key_array = ska
+            @sti_key_array = key
             @sti_dataset = sd
             @sti_key_map = skm
             @sti_model_map = smm
+            @sti_key_chooser = skc
             self.simple_table = nil
           end
         end
@@ -131,7 +174,7 @@ module Sequel
         # keys for all of their descendant classes.
         def sti_subclass_added(key)
           if sti_key_array
-            Sequel.synchronize{sti_key_array << key}
+            Sequel.synchronize{sti_key_array.push(*Array(key))}
             superclass.sti_subclass_added(key)
           end
         end
@@ -159,7 +202,7 @@ module Sequel
       module InstanceMethods
         # Set the sti_key column based on the sti_key_map.
         def before_create
-          send("#{model.sti_key}=", model.sti_key_map[model]) unless self[model.sti_key]
+          send("#{model.sti_key}=", model.sti_key_chooser.call(self)) unless self[model.sti_key]
           super
         end
       end

data/lib/sequel/plugins/touch.rb

@@ -52,7 +52,7 @@ module Sequel
         attr_accessor :touch_column
 
         # A hash specifying the associations to touch when instances are
-        # updated or destroyed. Keys are association dataset method name symbols and values
+        # updated or destroyed. Keys are association name symbols and values
         # are column name symbols.
         attr_reader :touched_associations
 
@@ -71,8 +71,8 @@ module Sequel
           associations.flatten.each do |a|
             a = {a=>touch_column} if a.is_a?(Symbol)
             a.each do |k,v|
-              raise(Error, "invalid association: #{k}") unless r = association_reflection(k)
-              touched_associations[r.dataset_method] = v
+              raise(Error, "invalid association: #{k}") unless association_reflection(k)
+              touched_associations[k] = v
             end
           end
         end
@@ -113,10 +113,22 @@ module Sequel
           Sequel::CURRENT_TIMESTAMP
         end
 
-        # Directly update the database using the association dataset for each association.
+        # Update the updated at field for all associated objects that should be touched.
         def touch_associations
-          model.touched_associations.each do |meth, column|
-            send(meth).update(column=>touch_association_value)
+          model.touched_associations.each do |assoc, column|
+            r = model.association_reflection(assoc)
+            next unless r.can_have_associated_objects?(self)
+            ds = send(r.dataset_method)
+
+            if ds.send(:joined_dataset?)
+              # Can't update all values at once, so update each instance individually.
+              # Instead if doing a simple save, update via the instance's dataset,
+              # to avoid going into an infinite loop in some cases.
+              send(r[:name]).each{|x| x.this.update(column=>touch_association_value)}
+            else
+              # Update all values at once for performance reasons.
+              ds.update(column=>touch_association_value)
+            end
           end
         end
 

data/lib/sequel/plugins/validation_class_methods.rb

@@ -385,6 +385,7 @@ module Sequel
             error_field = a
             a = Array(a)
             v = Array(v)
+            next if v.empty? || !v.all?
             ds = o.class.filter(a.zip(v))
             num_dups = ds.count
             allow = if num_dups == 0

data/lib/sequel/plugins/validation_helpers.rb

@@ -224,7 +224,9 @@ module Sequel
             ds = if where
               where.call(model.dataset, self, arr)
             else
-              model.where(arr.map{|x| [x, send(x)]})
+              vals = arr.map{|x| send(x)}
+              next unless vals.all?
+              model.where(arr.zip(vals))
             end
             ds = yield(ds) if block_given?
             ds = ds.exclude(pk_hash) unless new?

data/lib/sequel/sql.rb

@@ -377,6 +377,27 @@ module Sequel
         SQL::EmulatedFunction.new(:char_length, arg)
       end
 
+      # Return a delayed evaluation that uses the passed block. This is used
+      # to delay evaluations of the code to runtime.  For example, with
+      # the following code:
+      #
+      #   ds = DB[:table].where{column > Time.now}
+      #
+      # The filter is fixed to the time that where was called. Unless you are
+      # only using the dataset once immediately after creating it, that's
+      # probably not desired.  If you just want to set it to the time when the
+      # query is sent to the database, you can wrap it in Sequel.delay:
+      #
+      #   ds = DB[:table].where{column > Sequel.delay{Time.now}}
+      #
+      # Note that for dates and timestamps, you are probably better off using
+      # Sequel::CURRENT_DATE and Sequel::CURRENT_TIMESTAMP instead of this
+      # generic delayed evaluation facility.
+      def delay(&block)
+        raise(Error, "Sequel.delay requires a block") unless block
+        SQL::DelayedEvaluation.new(block)
+      end
+
       # Order the given argument descending.
       # Options:
       #
@@ -941,27 +962,33 @@ module Sequel
       #   ~from_value_pairs(hash)
       #   from_value_pairs(hash, :OR, true)
       def self.from_value_pairs(pairs, op=:AND, negate=false)
-        pairs = pairs.collect do |l,r|
-          ce = case r
-          when Range
-            new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
-          when ::Array, ::Sequel::Dataset
-            new(:IN, l, r)
-          when NegativeBooleanConstant
-            new(:"IS NOT", l, r.constant)
-          when BooleanConstant
-            new(:IS, l, r.constant)
-          when NilClass, TrueClass, FalseClass
-            new(:IS, l, r)
-          when Regexp
-            StringExpression.like(l, r)
-          else
-            new(:'=', l, r)
-          end
-          negate ? invert(ce) : ce
-        end
+        pairs = pairs.map{|l,r| from_value_pair(l, r)}
+        pairs.map!{|ce| invert(ce)} if negate
         pairs.length == 1 ? pairs.at(0) : new(op, *pairs)
       end
+
+      # Return a BooleanExpression based on the right side of the pair.
+      def self.from_value_pair(l, r)
+        case r
+        when Range
+          new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
+        when ::Array, ::Sequel::Dataset
+          new(:IN, l, r)
+        when NegativeBooleanConstant
+          new(:"IS NOT", l, r.constant)
+        when BooleanConstant
+          new(:IS, l, r.constant)
+        when NilClass, TrueClass, FalseClass
+          new(:IS, l, r)
+        when Regexp
+          StringExpression.like(l, r)
+        when DelayedEvaluation
+          Sequel.delay{from_value_pair(l, r.callable.call)}
+        else
+          new(:'=', l, r)
+        end
+      end
+      private_class_method :from_value_pair
       
       # Invert the expression, if possible.  If the expression cannot
       # be inverted, raise an error.  An inverted expression should match everything that the
@@ -1140,6 +1167,21 @@ module Sequel
                              Constants::NULL=>Constants::NOTNULL, Constants::NOTNULL=>Constants::NULL}
     end
 
+    # Represents a delayed evaluation, encapsulating a callable
+    # object which returns the value to use when called.
+    class DelayedEvaluation < GenericExpression
+      # A callable object that returns the value of the evaluation
+      # when called. 
+      attr_reader :callable
+
+      # Set the callable object
+      def initialize(callable)
+        @callable = callable
+      end
+
+      to_s_method :delayed_evaluation_sql, '@callable'
+    end
+
     # Represents an SQL function call.
     class Function < GenericExpression
       # The SQL function to call

data/lib/sequel/version.rb

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

data/spec/adapters/firebird_spec.rb

@@ -253,68 +253,82 @@ describe "A Firebird database" do
 
   specify "should allow us to name the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test"}
-    @db.sqls.should == [
-      "DROP SEQUENCE SEQ_TEST",
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "CREATE SEQUENCE SEQ_TEST",
-      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "DROP SEQUENCE SEQ_TEST",
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "CREATE SEQUENCE SEQ_TEST",
+        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
+      ]
+    end
   end
 
   specify "should allow us to set the starting position for the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_start_position => 999}
-    @db.sqls.should == [
-      "DROP SEQUENCE SEQ_POSTS_ID",
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "CREATE SEQUENCE SEQ_POSTS_ID",
-      "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
-      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "DROP SEQUENCE SEQ_POSTS_ID",
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "CREATE SEQUENCE SEQ_POSTS_ID",
+        "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
+        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+      ]
+    end
   end
 
   specify "should allow us to name and set the starting position for the sequences" do
     @db.create_table(:posts){primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999}
-    @db.sqls.should == [
-      "DROP SEQUENCE SEQ_TEST",
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "CREATE SEQUENCE SEQ_TEST",
-      "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
-      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "DROP SEQUENCE SEQ_TEST",
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "CREATE SEQUENCE SEQ_TEST",
+        "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
+        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
+      ]
+    end
   end
 
   specify "should allow us to name the triggers" do
     @db.create_table(:posts){primary_key :id, :trigger_name => "trig_test"}
-    @db.sqls.should == [
-      "DROP SEQUENCE SEQ_POSTS_ID",
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "CREATE SEQUENCE SEQ_POSTS_ID",
-      "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "DROP SEQUENCE SEQ_POSTS_ID",
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "CREATE SEQUENCE SEQ_POSTS_ID",
+        "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+      ]
+    end
   end
 
   specify "should allow us to not create the sequence" do
     @db.create_table(:posts){primary_key :id, :create_sequence => false}
-    @db.sqls.should == [
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
+      ]
+    end
   end
 
   specify "should allow us to not create the trigger" do
     @db.create_table(:posts){primary_key :id, :create_trigger => false}
-    @db.sqls.should == [
-      "DROP SEQUENCE SEQ_POSTS_ID",
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
-      "CREATE SEQUENCE SEQ_POSTS_ID",
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "DROP SEQUENCE SEQ_POSTS_ID",
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
+        "CREATE SEQUENCE SEQ_POSTS_ID",
+      ]
+    end
   end
 
   specify "should allow us to not create either the sequence nor the trigger" do
     @db.create_table(:posts){primary_key :id, :create_sequence => false, :create_trigger => false}
-    @db.sqls.should == [
-      "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
-    ]
+    check_sqls do
+      @db.sqls.should == [
+        "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
+      ]
+    end
   end
 
   specify "should support column operations" do