sequel 3.38.0 → 3.39.0

data/lib/sequel/plugins/defaults_setter.rb

@@ -37,11 +37,25 @@ module Sequel
 
         private
 
+        # Parse the cached database schema for this model and set the default values appropriately.
         def set_default_values
           h = {}
-          @db_schema.each{|k, v| h[k] = v[:ruby_default] if v[:ruby_default]} if @db_schema
+          @db_schema.each{|k, v| h[k] = convert_default_value(v[:ruby_default]) unless v[:ruby_default].nil?} if @db_schema
           @default_values = h
         end
+
+        # Handle the CURRENT_DATE and CURRENT_TIMESTAMP values specially by returning an appropriate Date or
+        # Time/DateTime value.
+        def convert_default_value(v)
+          case v
+          when Sequel::CURRENT_DATE
+            lambda{Date.today}
+          when Sequel::CURRENT_TIMESTAMP
+            lambda{Sequel.datetime_class.now}
+          else
+            v
+          end
+        end
       end
 
       module InstanceMethods

data/lib/sequel/plugins/dirty.rb

@@ -14,7 +14,7 @@ module Sequel
     #   artist.name                   # => 'Foo'
     #   artist.column_changed?(:name) # false
     #
-    # It allows makes changed_columns more accurate in that it
+    # It also makes changed_columns more accurate in that it
     # can detect when a the column value is changed and then
     # changed back:
     #
@@ -183,7 +183,7 @@ module Sequel
 
         # If the values hash does not contain the column, make sure missing_initial_values
         # does so that it doesn't get deleted from changed_columns if changed back,
-        # and so that reseting the column value can be handled correctly.
+        # and so that resetting the column value can be handled correctly.
         def check_missing_initial_value(column)
           unless values.has_key?(column) || (miv = missing_initial_values).include?(column)
             miv << column

data/lib/sequel/plugins/identity_map.rb

@@ -153,7 +153,8 @@ module Sequel
         # The identity map key for an object of the current class with the given pk.
         # May not always be correct for a class which uses STI.
         def identity_map_key(pk)
-          "#{self}:#{pk ? Array(pk).join(',') : "nil:#{rand}"}"
+          pk = Array(pk)
+          "#{self}:#{pk.join(',')}" unless pk.compact.empty?
         end
 
         # If the identity map is in use, check it for a current copy of the object.
@@ -164,12 +165,14 @@ module Sequel
         # fields and request other, potentially overlapping fields in a new query,
         # and not have the second query override fields you modified.
         def call(row)
-          return super unless idm = identity_map
-          if o = idm[identity_map_key(Array(primary_key).map{|x| row[x]})]
+          return super unless (idm = identity_map) && (pk = primary_key)
+          if (k = identity_map_key(Array(pk).map{|x| row[x]})) && (o = idm[k])
             o.merge_db_update(row)
           else
             o = super
-            idm[identity_map_key(o.pk)] = o
+            if (k = identity_map_key(o.pk))
+              idm[k] = o
+            end
           end
           o
         end
@@ -196,7 +199,7 @@ module Sequel
         # Check the current identity map if it exists for the object with
         # the matching pk.  If one is found, return it, otherwise call super.
         def primary_key_lookup(pk)
-          (idm = identity_map and o = idm[identity_map_key(pk)]) ? o : super
+          ((idm = identity_map) && (k = identity_map_key(pk)) && (o = idm[k])) ? o : super
         end
       end
 
@@ -204,8 +207,8 @@ module Sequel
         # Remove instances from the identity map cache if they are deleted.
         def delete
           super
-          if idm = model.identity_map
-            idm.delete(model.identity_map_key(pk))
+          if (idm = model.identity_map) && (k = model.identity_map_key(pk))
+            idm.delete(k)
           end
           self
         end
@@ -239,7 +242,8 @@ module Sequel
           if cache_lookup &&
             !dynamic_opts[:callback] &&
             (idm = klass.identity_map) &&
-            (o = idm[klass.identity_map_key(_associated_object_pk(opts[:key]))])
+            (k = klass.identity_map_key(_associated_object_pk(opts[:key]))) && 
+            (o = idm[k])
             o
           else
             super

data/lib/sequel/plugins/subclasses.rb

@@ -15,13 +15,27 @@ module Sequel
     #   sc2.subclasses  # []
     #   ssc1.subclasses # []
     #   c.descendents   # [sc1, ssc1, sc2]
+    #
+    # You can provide a block when loading the plugin, and it will be called
+    # with each subclass created:
+    #
+    #   a = []
+    #   Sequel::Model.plugin(:subclasses){|sc| a << sc}
+    #   class A < Sequel::Model; end
+    #   class B < Sequel::Model; end
+    #   a # => [A, B]
     module Subclasses
       # Initialize the subclasses instance variable for the model.
-      def self.apply(model)
+      def self.apply(model, &block)
         model.instance_variable_set(:@subclasses, [])
+        model.instance_variable_set(:@on_subclass, block)
       end
 
       module ClassMethods
+        # Callable object that should be called with every descendent
+        # class created.
+        attr_reader :on_subclass
+
         # All subclasses for the current model.  Does not
         # include the model itself.
         attr_reader :subclasses
@@ -38,6 +52,10 @@ module Sequel
           super
           Sequel.synchronize{subclasses << subclass}
           subclass.instance_variable_set(:@subclasses, [])
+          if on_subclass
+            subclass.instance_variable_set(:@on_subclass, on_subclass)
+            on_subclass.call(subclass)
+          end
         end
 
         private

data/lib/sequel/plugins/tree.rb

@@ -4,7 +4,7 @@ module Sequel
     # treat a Model as a tree.  
     #
     # A column for holding the parent key is required and is :parent_id by default.  
-    # This may be overridden by passing column name via :key
+    # This may be overridden by passing column name via :key.
     #
     # Optionally, a column to control order of nodes returned can be specified
     # by passing column name via :order.
@@ -98,7 +98,7 @@ module Sequel
           nodes 
         end
 
-        # Returns the root node of the tree that this node descends from
+        # Returns the root node of the tree that this node descends from.
         # This node is returned if it is a root node itself.
         def root
           ancestors.last || self
@@ -124,7 +124,7 @@ module Sequel
         end
       end
 
-      # Plugin included when :single_root option is passed
+      # Plugin included when :single_root option is passed.
       module SingleRoot
         module ClassMethods
           # Returns the single root node.

data/lib/sequel/plugins/validation_helpers.rb

@@ -193,19 +193,39 @@ module Sequel
         # since it can deal with a grouping of multiple attributes.
         #
         # Possible Options:
-        # * :message - The message to use (default: 'is already taken')
-        # * :only_if_modified - Only check the uniqueness if the object is new or
-        #   one of the columns has been modified.
+        # :message :: The message to use (default: 'is already taken')
+        # :only_if_modified :: Only check the uniqueness if the object is new or
+        #                      one of the columns has been modified.
+        # :where :: A callable object where call takes three arguments, a dataset,
+        #           the current object, and an array of columns, and should return
+        #           a modified dataset that is filtered to include only rows with
+        #           the same values as the current object for each column in the array.
+        #
+        # If you want to to a case insensitive uniqueness validation on a database that
+        # is case sensitive by default, you can use:
+        #
+        #   :where=>(proc do |ds, obj, cols|
+        #     ds.where(cols.map do |c|
+        #       v = obj.send(c)
+        #       v = v.downcase if v
+        #       [Sequel.function(:lower, c), v]
+        #     end)
+        #   end)
         def validates_unique(*atts)
           opts = default_validation_helpers_options(:unique)
           if atts.last.is_a?(Hash)
             opts = opts.merge(atts.pop)
           end
           message = validation_error_message(opts[:message])
+          where = opts[:where]
           atts.each do |a|
             arr = Array(a)
             next if opts[:only_if_modified] && !new? && !arr.any?{|x| changed_columns.include?(x)}
-            ds = model.filter(arr.map{|x| [x, send(x)]})
+            ds = if where
+              where.call(model.dataset, self, arr)
+            else
+              model.where(arr.map{|x| [x, send(x)]})
+            end
             ds = yield(ds) if block_given?
             ds = ds.exclude(pk_hash) unless new?
             errors.add(a, message) unless ds.count == 0

data/lib/sequel/sql.rb

@@ -60,29 +60,38 @@ module Sequel
 
     # Base class for all SQL expression objects.
     class Expression
-      # Expression objects are assumed to be value objects, where their
-      # attribute values can't change after assignment.  In order to make
-      # it easy to define equality and hash methods, subclass
-      # instances assume that the only values that affect the results of
-      # such methods are the values of the object's attributes.
-      def self.attr_reader(*args)
-        super
-        comparison_attrs.concat(args)
-      end
+      @comparison_attrs = []
+
+      class << self
+        # All attributes used for equality and hash methods.
+        attr_reader :comparison_attrs
+
+        # Expression objects are assumed to be value objects, where their
+        # attribute values can't change after assignment.  In order to make
+        # it easy to define equality and hash methods, subclass
+        # instances assume that the only values that affect the results of
+        # such methods are the values of the object's attributes.
+        def attr_reader(*args)
+          super
+          comparison_attrs.concat(args)
+        end
 
-      # All attributes used for equality and hash methods.
-      def self.comparison_attrs
-        @comparison_attrs ||= self == Expression ? [] : superclass.comparison_attrs.clone
-      end
+        # Copy the comparison_attrs into the subclass.
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@comparison_attrs, comparison_attrs.dup)
+        end
+
+          private
 
-      # Create a to_s instance method that takes a dataset, and calls
-      # the method provided on the dataset with args as the argument (self by default).
-      # Used to DRY up some code.
-      def self.to_s_method(meth, args=:self) # :nodoc:
-        class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
-        class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
+        # Create a to_s instance method that takes a dataset, and calls
+        # the method provided on the dataset with args as the argument (self by default).
+        # Used to DRY up some code.
+        def to_s_method(meth, args=:self) # :nodoc:
+          class_eval("def to_s(ds) ds.#{meth}(#{args}) end", __FILE__, __LINE__)
+          class_eval("def to_s_append(ds, sql) ds.#{meth}_append(sql, #{args}) end", __FILE__, __LINE__)
+        end
       end
-      private_class_method :to_s_method
 
       # Alias of <tt>eql?</tt>
       def ==(other)
@@ -140,6 +149,9 @@ module Sequel
       # Bitwise mathematical operators used in +NumericMethods+
       BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]
 
+      # Operators that check for equality
+      EQUALITY_OPERATORS = [:'=', :'!=']
+
       # Inequality operators used in +InequalityMethods+
       INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]
 
@@ -152,10 +164,14 @@ module Sequel
       # Operators that use IS, used for special casing to override literal true/false values
       IS_OPERATORS = [:IS, :'IS NOT']
 
+      # Operators that do pattern matching via regular expressions
+      REGEXP_OPERATORS = [:~, :'!~', :'~*', :'!~*']
+      
+      # Operators that do pattern matching via LIKE
+      LIKE_OPERATORS = [:LIKE, :'NOT LIKE', :ILIKE, :'NOT ILIKE']
+
       # Operator symbols that take exactly two arguments
-      TWO_ARITY_OPERATORS = [:'=', :'!=', :LIKE, :'NOT LIKE', \
-        :~, :'!~', :'~*', :'!~*', :ILIKE, :'NOT ILIKE'] + \
-        INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS
+      TWO_ARITY_OPERATORS = EQUALITY_OPERATORS + INEQUALITY_OPERATORS + IS_OPERATORS + IN_OPERATORS + REGEXP_OPERATORS + LIKE_OPERATORS
 
       # Operator symbols that take one or more arguments
       N_ARITY_OPERATORS = [:AND, :OR, :'||'] + MATHEMATICAL_OPERATORS + BITWISE_OPERATORS
@@ -352,6 +368,15 @@ module Sequel
         cast(arg, sql_type || String).sql_string
       end
 
+      # Return an emulated function call for getting the number of characters
+      # in the argument:
+      #
+      #   Sequel.char_length(:a) # char_length(a) -- Most databases
+      #   Sequel.char_length(:a) # length(a) -- SQLite
+      def char_length(arg)
+        SQL::EmulatedFunction.new(:char_length, arg)
+      end
+
       # Order the given argument descending.
       # Options:
       #
@@ -567,6 +592,15 @@ module Sequel
         SQL::Subscript.new(exp, subs.flatten)
       end
 
+      # Return an emulated function call for trimming a string of spaces from
+      # both sides (similar to ruby's String#strip).
+      #
+      #   Sequel.trim(:a) # trim(a) -- Most databases
+      #   Sequel.trim(:a) # ltrim(rtrim(a)) -- Microsoft SQL Server
+      def trim(arg)
+        SQL::EmulatedFunction.new(:trim, arg)
+      end
+
       # Return a <tt>SQL::ValueList</tt> created from the given array.  Used if the array contains
       # all two element arrays and you want it treated as an SQL value list (IN predicate) 
       # instead of as a conditions specifier (similar to a hash).  This is not necessary if you are using
@@ -1071,7 +1105,7 @@ module Sequel
     
     # Represents inverse boolean constants (currently only +NOTNULL+). A
     # special class to allow for special behavior.
-    class NegativeBooleanConstant < BooleanConstant
+    class NegativeBooleanConstant < Constant
       to_s_method :negative_boolean_constant_sql, '@constant'
     end
     
@@ -1110,6 +1144,12 @@ module Sequel
 
       to_s_method :function_sql
     end
+
+    # Represents an SQL function call that is translated/emulated
+    # on databases that lack support for such a function.
+    class EmulatedFunction < Function
+      to_s_method :emulated_function_sql
+    end
     
     class GenericExpression
       include AliasMethods

data/lib/sequel/timezones.rb

@@ -165,15 +165,23 @@ module Sequel
         convert_input_timestamp(ary, input_timezone)
       when Time
         if datetime_class == DateTime
-          v.respond_to?(:to_datetime) ? v.to_datetime : string_to_datetime(v.iso8601)
+          if v.respond_to?(:to_datetime)
+            v.to_datetime
+          else
+            # Ruby 1.8 code, %N not available and %z broken on Windows
+            offset_hours, offset_minutes = (v.utc_offset/60).divmod(60)
+            string_to_datetime(v.strftime("%Y-%m-%dT%H:%M:%S") << sprintf(".%06i%+03i%02i", v.usec, offset_hours, offset_minutes))
+          end
         else
           v
         end
       when DateTime
         if datetime_class == DateTime
           v
+        elsif v.respond_to?(:to_time)
+          v.to_time
         else
-          v.respond_to?(:to_time) ? v.to_time : string_to_datetime(v.to_s)
+          string_to_datetime(v.strftime("%FT%T.%N%z"))
         end
       else
         raise InvalidValue, "Invalid convert_input_timestamp type: #{v.inspect}"

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 = 38
+  MINOR = 39
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/mssql_spec.rb

@@ -18,23 +18,6 @@ def logger.method_missing(m, msg)
 end
 MSSQL_DB.loggers = [logger]
 
-MSSQL_DB.create_table! :test do
-  String :name, :type=>:text
-  Integer :value, :index => true
-end
-MSSQL_DB.create_table! :test2 do
-  String :name, :type=>:text
-  Integer :value
-end
-MSSQL_DB.create_table! :test3 do
-  Integer :value
-  Time :time
-end
-MSSQL_DB.create_table! :test4 do
-  String :name, :size => 20
-  column :value, 'varbinary(max)'
-end
-
 describe "A MSSQL database" do
   before do
     @db = MSSQL_DB
@@ -54,7 +37,20 @@ describe "A MSSQL database" do
     proc{@db.server_version}.should_not raise_error
     proc{@db.dataset.server_version}.should_not raise_error
   end
+end
   
+describe "A MSSQL database" do
+  before do
+    @db = MSSQL_DB
+    @db.create_table! :test3 do
+      Integer :value
+      Time :time
+    end
+  end
+  after do
+    @db.drop_table?(:test3)
+  end
+
   specify "should work with NOLOCK" do
     @db.transaction{@db[:test3].nolock.all.should == []}
   end
@@ -379,12 +375,15 @@ describe "MSSSQL::Dataset#insert" do
   before do
     @db = MSSQL_DB
     @db.create_table!(:test5){primary_key :xid; Integer :value}
+    @db.create_table! :test4 do
+      String :name, :size => 20
+      column :value, 'varbinary(max)'
+    end
     @db.sqls.clear
     @ds = @db[:test5]
   end
   after do
-    @db[:test4].delete
-    @db.drop_table?(:test5)
+    @db.drop_table?(:test5, :test4)
   end
 
   specify "should have insert_select return nil if disable_insert_output is used" do
@@ -409,11 +408,9 @@ describe "MSSSQL::Dataset#insert" do
     b.length.should == blob.length
     b.should == blob
   end
-end
 
-describe "MSSSQL::Dataset#disable_insert_output" do
   specify "should play nicely with simple_select_all?" do
-    MSSQL_DB[:test].disable_insert_output.send(:simple_select_all?).should == true
+    MSSQL_DB[:test4].disable_insert_output.send(:simple_select_all?).should == true
   end
 end
 
@@ -462,16 +459,20 @@ describe "A MSSQL database" do
 end
 
 describe "MSSQL::Database#rename_table" do
+  after do
+    MSSQL_DB.drop_table?(:foo)
+  end
+
   specify "should work on non-schema bound tables which need escaping" do
     MSSQL_DB.quote_identifiers = true
     MSSQL_DB.create_table! :'foo bar' do
       text :name
     end
-    MSSQL_DB.drop_table? :baz
-    proc { MSSQL_DB.rename_table 'foo bar', 'baz' }.should_not raise_error
+    MSSQL_DB.drop_table? :foo
+    proc { MSSQL_DB.rename_table 'foo bar', 'foo' }.should_not raise_error
   end
   
-  specify "should workd on schema bound tables" do
+  specify "should work on schema bound tables" do
     MSSQL_DB.execute(<<-SQL)
       IF NOT EXISTS (SELECT * FROM sys.schemas WHERE name = 'MY')
         EXECUTE sp_executesql N'create schema MY'