sequel 3.44.0 → 3.45.0

data/lib/sequel/database/misc.rb

@@ -201,6 +201,13 @@ module Sequel
       Sequel.synchronize{prepared_statements[name]}
     end
 
+    # Proxy the quote_identifier method to the dataset,
+    # useful for quoting unqualified identifiers for use
+    # outside of datasets.
+    def quote_identifier(v)
+      schema_utility_dataset.quote_identifier(v)
+    end
+    
     # Default serial primary key options, used by the table creation
     # code.
     def serial_primary_key_options
@@ -326,9 +333,9 @@ module Sequel
       []
     end
 
-    # A hash with regexp keys and exception class values, used
+    # An enumerable yielding pairs of regexps and exception classes, used
     # to match against underlying driver exception messages in
-    # order to raise a more specific Sequel::Error subclass.
+    # order to raise a more specific Sequel::DatabaseError subclass.
     def database_error_regexps
       DEFAULT_DATABASE_ERROR_REGEXPS
     end
@@ -339,19 +346,52 @@ module Sequel
       database_specific_error_class(exception, opts) || DatabaseError
     end
     
+    # Return the SQLState for the given exception, if one can be
+    # determined
+    def database_exception_sqlstate(exception, opts)
+      nil
+    end
+
     # Return a specific Sequel::DatabaseError exception class if
     # one is appropriate for the underlying exception,
     # or nil if there is no specific exception class.
     def database_specific_error_class(exception, opts)
       return DatabaseDisconnectError if disconnect_error?(exception, opts)
 
-      database_error_regexps.each do |regexp, klass|
-        return klass if exception.message =~ regexp
+      if sqlstate = database_exception_sqlstate(exception, opts)
+        if klass = database_specific_error_class_from_sqlstate(sqlstate)
+          return klass
+        end
+      else
+        database_error_regexps.each do |regexp, klass|
+          return klass if exception.message =~ regexp
+        end
       end
 
       nil
     end
     
+    NOT_NULL_CONSTRAINT_SQLSTATES = %w'23502'.freeze.each{|s| s.freeze}
+    FOREIGN_KEY_CONSTRAINT_SQLSTATES = %w'23503 23506 23504'.freeze.each{|s| s.freeze}
+    UNIQUE_CONSTRAINT_SQLSTATES = %w'23505'.freeze.each{|s| s.freeze}
+    CHECK_CONSTRAINT_SQLSTATES = %w'23513 23514'.freeze.each{|s| s.freeze}
+    SERIALIZATION_CONSTRAINT_SQLSTATES = %w'40001'.freeze.each{|s| s.freeze}
+    # Given the SQLState, return the appropriate DatabaseError subclass.
+    def database_specific_error_class_from_sqlstate(sqlstate)
+      case sqlstate
+      when *NOT_NULL_CONSTRAINT_SQLSTATES
+        NotNullConstraintViolation
+      when *FOREIGN_KEY_CONSTRAINT_SQLSTATES
+        ForeignKeyConstraintViolation
+      when *UNIQUE_CONSTRAINT_SQLSTATES
+        UniqueConstraintViolation
+      when *CHECK_CONSTRAINT_SQLSTATES
+        CheckConstraintViolation
+      when *SERIALIZATION_CONSTRAINT_SQLSTATES
+        SerializationFailure
+      end
+    end
+    
     # Return true if exception represents a disconnect error, false otherwise.
     def disconnect_error?(exception, opts)
       opts[:disconnect]
@@ -435,12 +475,14 @@ module Sequel
         (value.is_a?(String) && value =~ LEADING_ZERO_RE) ? Integer(value, 10) : Integer(value)
       end
     else
+    # :nocov:
       # Replacement string when replacing leading zeroes.
       LEADING_ZERO_REP = "\\1".freeze 
       # Typecast the value to an Integer
       def typecast_value_integer(value)
         Integer(value.is_a?(String) ? value.sub(LEADING_ZERO_RE, LEADING_ZERO_REP) : value)
       end
+    # :nocov:
     end
 
     # Typecast the value to a String

data/lib/sequel/database/query.rb

@@ -251,21 +251,26 @@ module Sequel
     #
     # The following general options are respected:
     #
-    # :disconnect :: Can be set to :retry to automatically retry the transaction with
-    #                a new connection object if it detects a disconnect on the connection.
-    #                Note that this should not be used unless the entire transaction
-    #                block is idempotent, as otherwise it can cause non-idempotent
-    #                behavior to execute multiple times.  This does no checking for
-    #                infinite loops, so if your transaction will repeatedly raise a
-    #                disconnection error, this will cause the transaction block to loop
-    #                indefinitely.
+    # :disconnect :: If set to :retry, automatically sets the :retry_on option
+    #                with a Sequel::DatabaseDisconnectError.  This option is only
+    #                present for backwards compatibility, please use the :retry_on
+    #                option instead.
     # :isolation :: The transaction isolation level to use for this transaction,
     #               should be :uncommitted, :committed, :repeatable, or :serializable,
     #               used if given and the database/adapter supports customizable
     #               transaction isolation levels.
+    # :num_retries :: The number of times to retry if the :retry_on option is used.
+    #                 The default is 5 times.  Can be set to nil to retry indefinitely,
+    #                 but that is not recommended.
     # :prepare :: A string to use as the transaction identifier for a
     #             prepared transaction (two-phase commit), if the database/adapter
     #             supports prepared transactions.
+    # :retry_on :: An exception class or array of exception classes for which to
+    #              automatically retry the transaction.  Can only be set if not inside
+    #              an existing transaction.
+    #              Note that this should not be used unless the entire transaction
+    #              block is idempotent, as otherwise it can cause non-idempotent
+    #              behavior to execute multiple times.
     # :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
     #              raised, or :always to always rollback even if no exceptions occur
     #              (useful for testing).
@@ -284,16 +289,28 @@ module Sequel
     #                 and :remote_write (9.2+).
     def transaction(opts={}, &block)
       if opts[:disconnect] == :retry
+        raise(Error, 'cannot specify both :disconnect=>:retry and :retry_on') if opts[:retry_on]
+        return transaction(opts.merge(:retry_on=>Sequel::DatabaseDisconnectError, :disconnect=>nil), &block)
+      end
+
+      if retry_on = opts[:retry_on]
+        num_retries = opts.fetch(:num_retries, 5)
         begin
-          transaction(opts.merge(:disconnect=>:disallow), &block)
-        rescue Sequel::DatabaseDisconnectError
-          retry
+          transaction(opts.merge(:retry_on=>nil, :retrying=>true), &block)
+        rescue *retry_on
+          if num_retries
+            num_retries -= 1
+            retry if num_retries >= 0
+          else
+            retry
+          end
+          raise
         end
       else
         synchronize(opts[:server]) do |conn|
           if already_in_transaction?(conn, opts)
-            if opts[:disconnect] == :disallow
-              raise Sequel::Error, "cannot set :disconnect=>:retry if you are already inside a transaction"
+            if opts[:retrying]
+              raise Sequel::Error, "cannot set :disconnect=>:retry or :retry_on options if you are already inside a transaction"
             end
             return yield(conn)
           end
@@ -501,6 +518,7 @@ module Sequel
     end
 
     if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or RUBY_ENGINE == 'rbx') and RUBY_VERSION < '1.9'
+    # :nocov:
       # Whether to commit the current transaction. On ruby 1.8 and rubinius,
       # Thread.current.status is checked because Thread#kill skips rescue
       # blocks (so exception would be nil), but the transaction should
@@ -518,6 +536,7 @@ module Sequel
           end
         end
       end
+    # :nocov:
     else
       # Whether to commit the current transaction.  On ruby 1.9 and JRuby,
       # transactions will be committed if Thread#kill is used on an thread
@@ -642,7 +661,7 @@ module Sequel
         :boolean
       when /\A(real|float|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?)|(?:small)?money)\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob

data/lib/sequel/database/schema_methods.rb

@@ -705,11 +705,6 @@ module Sequel
       schema_utility_dataset.quote_schema_table(table)
     end
     
-    # Proxy the quote_identifier method to the dataset, used for quoting tables and columns.
-    def quote_identifier(v)
-      schema_utility_dataset.quote_identifier(v)
-    end
-    
     # SQL DDL statement for renaming a table.
     def rename_table_sql(name, new_name)
       "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"

data/lib/sequel/dataset/misc.rb

@@ -49,6 +49,15 @@ module Sequel
     def each_server
       db.servers.each{|s| yield server(s)}
     end
+
+    # Returns the string with the LIKE metacharacters (% and _) escaped.
+    # Useful for when the LIKE term is a user-provided string where metacharacters should not
+    # be recognized. Example:
+    #
+    #   ds.escape_like("foo\\%_") # 'foo\\\%\_'
+    def escape_like(string)
+      string.gsub(/[\\%_]/){|m| "\\#{m}"}
+    end
    
     # Alias of +first_source_alias+
     def first_source

data/lib/sequel/dataset/mutation.rb

@@ -6,14 +6,17 @@ module Sequel
     # ---------------------
     
     # All methods that should have a ! method added that modifies the receiver.
-    MUTATION_METHODS = QUERY_METHODS - [:paginate, :naked]
+    MUTATION_METHODS = QUERY_METHODS - [:paginate, :naked, :from_self]
     
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
     # options of the resulting dataset.
     def self.def_mutation_method(*meths)
+      options = meths.pop if meths.last.is_a?(Hash)
+      mod = options[:module] if options
+      mod ||= self
       meths.each do |meth|
-        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
+        mod.class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
       end
     end
     
@@ -33,11 +36,10 @@ module Sequel
     # a single hash argument and returns the object you want #each to return.
     attr_accessor :row_proc
     
-    # Add a mutation method to this dataset instance.
-    def def_mutation_method(*meths)
-      meths.each do |meth|
-        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end", __FILE__, __LINE__)
-      end
+    # Avoid self-referential dataset by cloning.
+    def from_self!(*args, &block)
+      @opts.merge!(clone.from_self(*args, &block).opts)
+      self
     end
 
     # Remove the row_proc from the current dataset.

data/lib/sequel/dataset/sql.rb

@@ -189,6 +189,7 @@ module Sequel
     ARRAY_EMPTY = '(NULL)'.freeze
     AS = ' AS '.freeze
     ASC = ' ASC'.freeze
+    BACKSLASH = "\\".freeze
     BOOL_FALSE = "'f'".freeze
     BOOL_TRUE = "'t'".freeze
     BRACKET_CLOSE =  ']'.freeze
@@ -219,6 +220,7 @@ module Sequel
     DOUBLE_APOS = "''".freeze
     DOUBLE_QUOTE = '""'.freeze
     EQUAL = ' = '.freeze
+    ESCAPE = " ESCAPE ".freeze
     EXTRACT = 'extract('.freeze
     EXISTS = ['EXISTS '.freeze].freeze
     FOR_UPDATE = ' FOR UPDATE'.freeze
@@ -239,6 +241,7 @@ module Sequel
     INTO = " INTO ".freeze
     IS_LITERALS = {nil=>'NULL'.freeze, true=>'TRUE'.freeze, false=>'FALSE'.freeze}.freeze
     IS_OPERATORS = ::Sequel::SQL::ComplexExpression::IS_OPERATORS
+    LIKE_OPERATORS = ::Sequel::SQL::ComplexExpression::LIKE_OPERATORS
     LIMIT = " LIMIT ".freeze
     N_ARITY_OPERATORS = ::Sequel::SQL::ComplexExpression::N_ARITY_OPERATORS
     NOT_SPACE = 'NOT '.freeze
@@ -455,6 +458,16 @@ module Sequel
           literal_append(sql, vals)
           sql << PAREN_CLOSE
         end
+      when :LIKE, :'NOT LIKE'
+        sql << PAREN_OPEN
+        literal_append(sql, args.at(0))
+        sql << SPACE << op.to_s << SPACE
+        literal_append(sql, args.at(1))
+        sql << ESCAPE
+        literal_append(sql, BACKSLASH)
+        sql << PAREN_CLOSE
+      when :ILIKE, :'NOT ILIKE'
+        complex_expression_sql_append(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|v| Sequel.function(:UPPER, v)})
       when *TWO_ARITY_OPERATORS
         if REGEXP_OPERATORS.include?(op) && !supports_regexp?
           raise InvalidOperation, "Pattern matching via regular expressions is not supported on #{db.database_type}"

data/lib/sequel/exceptions.rb

@@ -40,6 +40,9 @@ module Sequel
   # Error raised when Sequel determines a database unique constraint has been violated.
   class UniqueConstraintViolation < ConstraintViolation; end
 
+  # Error raised when Sequel determines a serialization failure/deadlock in the database.
+  class SerializationFailure < DatabaseError; end
+
   # Error raised on an invalid operation, such as trying to update or delete
   # a joined or grouped dataset.
   class InvalidOperation < Error; end

data/lib/sequel/extensions/connection_validator.rb

@@ -21,7 +21,7 @@
 # Note that if you set the timeout to validate connections
 # on every checkout, you should probably manually control
 # connection checkouts on a coarse basis, using
-# Database#synchonrize.  In a web application, the optimal
+# Database#synchronize.  In a web application, the optimal
 # place for that would be a rack middleware.  Validating
 # connections on every checkout without setting up coarse
 # connection checkouts will hurt performance, in some cases

data/lib/sequel/extensions/date_arithmetic.rb

@@ -62,14 +62,6 @@ module Sequel
         ACCESS_DURATION_UNITS = DURATION_UNITS.zip(%w'yyyy m d h n s'.map{|s| s.freeze}).freeze
         DB2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s).freeze}).freeze
 
-        # Return an SQL fragment for the literalized version of the
-        # DateAdd expression.
-        def date_add_sql(da)
-          sql = ''
-          date_arith_sql_append(sql, da)
-          sql
-        end
-
         # Append the SQL fragment for the DateAdd expression to the SQL query.
         def date_add_sql_append(sql, da)
           h = da.interval

data/lib/sequel/extensions/eval_inspect.rb

@@ -30,10 +30,12 @@ module Sequel
       when Time
         datepart = "%Y-%m-%dT" unless obj.is_a?(Sequel::SQLTime)
         if RUBY_VERSION < '1.9'
+        # :nocov:
           # Time on 1.8 doesn't handle %N (or %z on Windows), manually set the usec value in the string
           hours, mins = obj.utc_offset.divmod(3600)
           mins /= 60
           "#{obj.class}.parse(#{obj.strftime("#{datepart}%H:%M:%S.#{sprintf('%06i%+03i%02i', obj.usec, hours, mins)}").inspect})#{'.utc' if obj.utc?}"
+        # :nocov:
         else
           "#{obj.class}.parse(#{obj.strftime("#{datepart}%T.%N%z").inspect})#{'.utc' if obj.utc?}"
         end

data/lib/sequel/extensions/named_timezones.rb

@@ -37,6 +37,13 @@ module Sequel
   self.datetime_class = DateTime
   
   module NamedTimezones
+    # Handles TZInfo::AmbiguousTime exceptions automatically by providing a
+    # proc called with both the datetime value being converted as well as
+    # the array of TZInfo::TimezonePeriod results. Example:
+    #
+    #   Sequel.tzinfo_disambiguator = proc{|datetime, periods| periods.first}
+    attr_accessor :tzinfo_disambiguator
+
     private 
     
     # Assume the given DateTime has a correct time but a wrong timezone.  It is
@@ -44,7 +51,7 @@ module Sequel
     # Keep the time the same but convert the timezone to the input_timezone.
     # Expects the input_timezone to be a TZInfo::Timezone instance.
     def convert_input_datetime_other(v, input_timezone)
-      local_offset = input_timezone.period_for_local(v).utc_total_offset_rational
+      local_offset = input_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
       (v - local_offset).new_offset(local_offset)
     end
 
@@ -54,7 +61,7 @@ module Sequel
       # TZInfo converts times, but expects the given DateTime to have an offset
       # of 0 and always leaves the timezone offset as 0
       v = output_timezone.utc_to_local(v.new_offset(0))
-      local_offset = output_timezone.period_for_local(v).utc_total_offset_rational
+      local_offset = output_timezone.period_for_local(v, &tzinfo_disambiguator_for(v)).utc_total_offset_rational
       # Convert timezone offset from UTC to the offset for the output_timezone
       (v - local_offset).new_offset(local_offset)
     end
@@ -63,6 +70,15 @@ module Sequel
     def convert_timezone_setter_arg(tz)
       tz.is_a?(String) ? TZInfo::Timezone.get(tz) : super
     end
+
+    # Return a disambiguation proc that provides both the datetime value
+    # and the periods, in order to allow the choice of period to depend
+    # on the datetime value.
+    def tzinfo_disambiguator_for(v)
+      if pr = @tzinfo_disambiguator
+        proc{|periods| pr.call(v, periods)}
+      end
+    end
   end
   
   extend NamedTimezones

data/lib/sequel/extensions/pg_array.rb

@@ -402,10 +402,12 @@ module Sequel
         end
 
         if Sequel::Postgres.respond_to?(:parse_pg_array)
+        # :nocov:
           # Use sequel_pg's C-based parser if it has already been defined.
           def call(string)
             PGArray.new(Sequel::Postgres.parse_pg_array(string, @converter), @type)
           end
+        # :nocov:
         else
           # Parse the string using Parser with the appropriate
           # converter, and return a PGArray with the appropriate database
@@ -431,7 +433,7 @@ module Sequel
         # recursive map of the output is done to make sure that the entires in the
         # correct type.
         def call(string)
-          array = JSON.parse(string.gsub(SUBST_RE){|m| SUBST[m]})
+          array = Sequel.parse_json(string.gsub(SUBST_RE){|m| SUBST[m]})
           array = Sequel.recursive_map(array, @converter) if @converter
           PGArray.new(array, @type)
         end
@@ -527,6 +529,7 @@ module Sequel
   Database.register_extension(:pg_array, Postgres::PGArray::DatabaseMethods)
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Array
     # Return a PGArray proxy to the receiver, using a
@@ -548,3 +551,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_array_ops.rb

@@ -257,6 +257,7 @@ module Sequel
   end
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Symbol
     include Sequel::Postgres::ArrayOpMethods
@@ -270,3 +271,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov:

data/lib/sequel/extensions/pg_hstore.rb

@@ -320,6 +320,7 @@ module Sequel
   Database.register_extension(:pg_hstore, Postgres::HStore::DatabaseMethods)
 end
 
+# :nocov:
 if Sequel.core_extensions?
   class Hash
     # Create a new HStore using the receiver as the input
@@ -343,3 +344,4 @@ if defined?(Sequel::CoreRefinements)
     end
   end
 end
+# :nocov: