sequel 5.57.0 → 5.60.0

data/lib/sequel/extensions/date_arithmetic.rb

@@ -32,6 +32,10 @@
 #
 #   DB[:table].select(add.as(:d)).where(sub > Sequel::CURRENT_TIMESTAMP)
 #
+# On most databases, the values you provide for years/months/days/etc. must
+# be numeric values and not arbitrary SQL expressions.  However, on PostgreSQL
+# 9.4+, use of arbitrary SQL expressions is supported.
+#
 # Related module: Sequel::SQL::DateAdd
 
 #
@@ -54,7 +58,16 @@ module Sequel
           interval = interval.parts
         end
         parts = {}
-        interval.each{|k,v| parts[k] = -v unless v.nil?}
+        interval.each do |k,v|
+          case v
+          when nil
+            # ignore
+          when Numeric
+            parts[k] = -v
+          else
+            parts[k] = Sequel::SQL::NumericExpression.new(:*, v, -1)
+          end
+        end
         DateAdd.new(expr, parts, opts)
       end
     end
@@ -68,6 +81,7 @@ module Sequel
       module DatasetMethods
         DURATION_UNITS = [:years, :months, :days, :hours, :minutes, :seconds].freeze
         DEF_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s.freeze}).freeze
+        POSTGRES_DURATION_UNITS = DURATION_UNITS.zip([:years, :months, :days, :hours, :mins, :secs].map{|s| s.to_s.freeze}).freeze
         MYSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s.upcase[0...-1]).freeze}).freeze
         MSSQL_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| Sequel.lit(s.to_s[0...-1]).freeze}).freeze
         H2_DURATION_UNITS = DURATION_UNITS.zip(DURATION_UNITS.map{|s| s.to_s[0...-1].freeze}).freeze
@@ -87,14 +101,28 @@ module Sequel
 
           cast = case db_type = db.database_type
           when :postgres
-            interval = String.new
-            each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
-              interval << "#{value} #{sql_unit} "
+            casted = Sequel.cast(expr, cast_type)
+
+            if db.server_version >= 90400
+              placeholder = []
+              vals = []
+              each_valid_interval_unit(h, POSTGRES_DURATION_UNITS) do |value, sql_unit|
+                placeholder << "#{', ' unless placeholder.empty?}#{sql_unit} := "
+                vals << value
+              end
+              interval = Sequel.function(:make_interval, Sequel.lit(placeholder, *vals)) unless vals.empty?
+            else
+              parts = String.new
+              each_valid_interval_unit(h, DEF_DURATION_UNITS) do |value, sql_unit|
+                parts << "#{value} #{sql_unit} "
+              end
+              interval = Sequel.cast(parts, :interval) unless parts.empty?
             end
-            if interval.empty?
-              return literal_append(sql, Sequel.cast(expr, cast_type))
+
+            if interval
+              return complex_expression_sql_append(sql, :+, [casted, interval])
             else
-              return complex_expression_sql_append(sql, :+, [Sequel.cast(expr, cast_type), Sequel.cast(interval, :interval)])
+              return literal_append(sql, casted)
             end
           when :sqlite
             args = [expr]

data/lib/sequel/extensions/duplicate_columns_handler.rb

@@ -77,7 +77,7 @@ module Sequel
     def duplicate_columns_handler_type(cols)
       handler = opts.fetch(:on_duplicate_columns){db.opts.fetch(:on_duplicate_columns, :warn)}
 
-      if handler.respond_to?(:call)
+      if defined?(handler.call)
         handler.call(cols)
       else
         handler

data/lib/sequel/extensions/is_distinct_from.rb

@@ -3,7 +3,7 @@
 # The is_distinct_from extension adds the ability to use the
 # SQL standard IS DISTINCT FROM operator, which is similar to the
 # not equals operator, except that NULL values are considered
-# equal.  Only PostgreSQL and H2 currently support this operator.  On 
+# equal.  PostgreSQL, SQLite 3.39+, and H2 currently support this operator.  On 
 # other databases, support is emulated.
 #
 # First, you need to load the extension into the database:
@@ -90,6 +90,8 @@ module Sequel
           case db.database_type
           when :postgres, :h2
             true
+          when :sqlite
+            db.sqlite_version >= 33900
           else
             false
           end

data/lib/sequel/extensions/pg_array.rb

@@ -301,7 +301,7 @@ module Sequel
         end
       end
 
-      unless Sequel::Postgres.respond_to?(:parse_pg_array)
+      unless defined?(Sequel::Postgres.parse_pg_array)
         require 'strscan'
 
         # PostgreSQL array parser that handles PostgreSQL array output format.
@@ -412,7 +412,7 @@ module Sequel
           @converter = converter
         end
 
-        if Sequel::Postgres.respond_to?(:parse_pg_array)
+        if defined?(Sequel::Postgres.parse_pg_array)
         # :nocov:
           # Use sequel_pg's C-based parser if it has already been defined.
           def call(string)

data/lib/sequel/extensions/pg_array_ops.rb

@@ -158,7 +158,7 @@ module Sequel
           Sequel.function(:hstore, self, wrap_array(arg))
         end
         # :nocov:
-        if Sequel.respond_to?(:hstore_op)
+        if defined?(Sequel.hstore_op)
         # :nocov:
           v = Sequel.hstore_op(v)
         end

data/lib/sequel/extensions/pg_enum.rb

@@ -144,7 +144,7 @@ module Sequel
           select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
         enum_labels.each_value(&:freeze)
 
-        if respond_to?(:register_array_type)
+        if defined?(register_array_type)
           array_types = metadata_dataset.
             from(:pg_type).
             where(:oid=>enum_labels.keys).

data/lib/sequel/extensions/pg_hstore.rb

@@ -76,7 +76,7 @@
 #
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of hstore types, load the pg_array extension before the
-# pg_interval extension:
+# pg_hstore extension:
 #
 #   DB.extension :pg_array, :pg_hstore
 #

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -296,7 +296,7 @@ module Sequel
 
       # Wrap argument in a PGArray if it is an array
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
+        if obj.is_a?(Array) && defined?(Sequel.pg_array) 
           Sequel.pg_array(obj)
         else
           obj
@@ -305,7 +305,7 @@ module Sequel
 
       # Wrap argument in an Hstore if it is a hash
       def wrap_input_hash(obj)
-        if obj.is_a?(Hash) && Sequel.respond_to?(:hstore) 
+        if obj.is_a?(Hash) && defined?(Sequel.hstore) 
           Sequel.hstore(obj)
         else
           obj
@@ -314,7 +314,7 @@ module Sequel
 
       # Wrap argument in a PGArrayOp if supported
       def wrap_output_array(obj)
-        if Sequel.respond_to?(:pg_array_op) 
+        if defined?(Sequel.pg_array_op) 
           Sequel.pg_array_op(obj)
         else
           obj

data/lib/sequel/extensions/pg_inet.rb

@@ -49,13 +49,13 @@ module Sequel
             meth = IPAddr.method(:new)
             add_conversion_proc(869, meth)
             add_conversion_proc(650, meth)
-            if respond_to?(:register_array_type)
+            if defined?(register_array_type)
               register_array_type('inet', :oid=>1041, :scalar_oid=>869)
               register_array_type('cidr', :oid=>651, :scalar_oid=>650)
             end
           end
 
-          if respond_to?(:register_array_type)
+          if defined?(register_array_type)
             register_array_type('macaddr', :oid=>1040, :scalar_oid=>829)
           end
           @schema_type_classes[:ipaddr] = IPAddr

data/lib/sequel/extensions/pg_interval.rb

@@ -144,7 +144,7 @@ module Sequel
         db.instance_exec do
           extend_datasets(IntervalDatasetMethods)
           add_conversion_proc(1186, Postgres::IntervalDatabaseMethods::PARSER)
-          if respond_to?(:register_array_type)
+          if defined?(register_array_type)
             register_array_type('interval', :oid=>1187, :scalar_oid=>1186)
           end
           @schema_type_classes[:interval] = ActiveSupport::Duration

data/lib/sequel/extensions/pg_json.rb

@@ -227,7 +227,7 @@ module Sequel
         db.instance_exec do
           add_conversion_proc(114, method(:_db_parse_json))
           add_conversion_proc(3802, method(:_db_parse_jsonb))
-          if respond_to?(:register_array_type)
+          if defined?(register_array_type)
             register_array_type('json', :oid=>199, :scalar_oid=>114)
             register_array_type('jsonb', :oid=>3807, :scalar_oid=>3802)
           end

data/lib/sequel/extensions/pg_json_ops.rb

@@ -123,6 +123,15 @@
 #   c = Sequel.pg_jsonb_op(:c)
 #   DB[:t].update(c['key1'] => 1.to_json, c['key2'] => "a".to_json)
 #
+# On PostgreSQL 15+, the <tt>IS [NOT] JSON</tt> operator is supported:
+#
+#   j.is_json                              # j IS JSON
+#   j.is_json(type: :object)               # j IS JSON OBJECT
+#   j.is_json(type: :object, unique: true) # j IS JSON OBJECT WITH UNIQUE
+#   j.is_not_json                          # j IS NOT JSON
+#   j.is_json(type: :array)                # j IS NOT JSON ARRAY
+#   j.is_json(unique: true)                # j IS NOT JSON WITH UNIQUE
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -151,6 +160,18 @@ module Sequel
       GET_PATH = ["(".freeze, " #> ".freeze, ")".freeze].freeze
       GET_PATH_TEXT = ["(".freeze, " #>> ".freeze, ")".freeze].freeze
 
+      IS_JSON = ["(".freeze, " IS JSON".freeze, "".freeze, ")".freeze].freeze
+      IS_NOT_JSON = ["(".freeze, " IS NOT JSON".freeze, "".freeze, ")".freeze].freeze
+      EMPTY_STRING = Sequel::LiteralString.new('').freeze
+      WITH_UNIQUE = Sequel::LiteralString.new(' WITH UNIQUE').freeze
+      IS_JSON_MAP = {
+        nil => EMPTY_STRING,
+        :value => Sequel::LiteralString.new(' VALUE').freeze,
+        :scalar => Sequel::LiteralString.new(' SCALAR').freeze,
+        :object => Sequel::LiteralString.new(' OBJECT').freeze,
+        :array => Sequel::LiteralString.new(' ARRAY').freeze
+      }.freeze
+
       # Get JSON array element or object field as json.  If an array is given,
       # gets the object at the specified path.
       #
@@ -233,6 +254,30 @@ module Sequel
         end
       end
 
+      # Return whether the json object can be parsed as JSON.
+      #
+      # Options:
+      # :type :: Check whether the json object can be parsed as a specific type
+      #          of JSON (:value, :scalar, :object, :array).
+      # :unique :: Check JSON objects for unique keys.
+      #
+      #   json_op.is_json                 # json IS JSON
+      #   json_op.is_json(type: :object)  # json IS JSON OBJECT
+      #   json_op.is_json(unique: true)   # json IS JSON WITH UNIQUE
+      def is_json(opts=OPTS)
+        _is_json(IS_JSON, opts)
+      end
+
+      # Return whether the json object cannot be parsed as JSON. The opposite
+      # of #is_json. See #is_json for options.
+      #
+      #   json_op.is_not_json                 # json IS NOT JSON
+      #   json_op.is_not_json(type: :object)  # json IS NOT JSON OBJECT
+      #   json_op.is_not_json(unique: true)   # json IS NOT JSON WITH UNIQUE
+      def is_not_json(opts=OPTS)
+        _is_json(IS_NOT_JSON, opts)
+      end
+
       # Returns a set of keys AS text in the json object.
       #
       #   json_op.keys # json_object_keys(json)
@@ -286,6 +331,13 @@ module Sequel
 
       private
 
+      # Internals of IS [NOT] JSON support
+      def _is_json(lit_array, opts)
+        raise Error, "invalid is_json :type option: #{opts[:type].inspect}" unless type = IS_JSON_MAP[opts[:type]]
+        unique = opts[:unique] ? WITH_UNIQUE : EMPTY_STRING
+        Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(lit_array, [self, type, unique]))
+      end
+
       # Return a placeholder literal with the given str and args, wrapped
       # in an JSONOp or JSONBOp, used by operators that return json or jsonb.
       def json_op(str, args)
@@ -306,7 +358,7 @@ module Sequel
       # Automatically wrap argument in a PGArray if it is a plain Array.
       # Requires that the pg_array extension has been loaded to work.
       def wrap_array(arg)
-        if arg.instance_of?(Array) && Sequel.respond_to?(:pg_array)
+        if arg.instance_of?(Array) && defined?(Sequel.pg_array)
           Sequel.pg_array(arg)
         else
           arg
@@ -600,7 +652,7 @@ module Sequel
 
       # Wrap argument in a PGArray if it is an array
       def wrap_input_array(obj)
-        if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
+        if obj.is_a?(Array) && defined?(Sequel.pg_array) 
           Sequel.pg_array(obj)
         else
           obj
@@ -609,7 +661,7 @@ module Sequel
 
       # Wrap argument in a JSONBArray or JSONBHash if it is an array or hash.
       def wrap_input_jsonb(obj)
-        if Sequel.respond_to?(:pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
+        if defined?(Sequel.pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
           Sequel.pg_jsonb(obj)
         else
           obj

data/lib/sequel/extensions/pg_multirange.rb

@@ -124,7 +124,7 @@ module Sequel
             register_multirange_type('datemultirange', :range_oid=>3912, :oid=>4535)
             register_multirange_type('int8multirange', :range_oid=>3926, :oid=>4536)
 
-            if respond_to?(:register_array_type)
+            if defined?(register_array_type)
               register_array_type('int4multirange', :oid=>6150, :scalar_oid=>4451, :scalar_typecast=>:int4multirange)
               register_array_type('nummultirange', :oid=>6151, :scalar_oid=>4532, :scalar_typecast=>:nummultirange)
               register_array_type('tsmultirange', :oid=>6152, :scalar_oid=>4533, :scalar_typecast=>:tsmultirange)
@@ -141,7 +141,7 @@ module Sequel
             add_conversion_proc(4533, PGMultiRange::Creator.new("tsmultirange", procs[3908]))
             add_conversion_proc(4534, PGMultiRange::Creator.new("tstzmultirange", procs[3910]))
 
-            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
+            if defined?(register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(6152, PGArray::Creator.new("tsmultirange", procs[4533]))
               add_conversion_proc(6153, PGArray::Creator.new("tstzmultirange", procs[4534]))
             end

data/lib/sequel/extensions/pg_range.rb

@@ -139,7 +139,7 @@ module Sequel
             register_range_type('tstzrange', :oid=>3910, :subtype_oid=>1184)
             register_range_type('daterange', :oid=>3912, :subtype_oid=>1082)
             register_range_type('int8range', :oid=>3926, :subtype_oid=>20)
-            if respond_to?(:register_array_type)
+            if defined?(register_array_type)
               register_array_type('int4range', :oid=>3905, :scalar_oid=>3904, :scalar_typecast=>:int4range)
               register_array_type('numrange', :oid=>3907, :scalar_oid=>3906, :scalar_typecast=>:numrange)
               register_array_type('tsrange', :oid=>3909, :scalar_oid=>3908, :scalar_typecast=>:tsrange)
@@ -154,7 +154,7 @@ module Sequel
             procs = conversion_procs
             add_conversion_proc(3908, Parser.new("tsrange", procs[1114]))
             add_conversion_proc(3910, Parser.new("tstzrange", procs[1184]))
-            if respond_to?(:register_array_type) && defined?(PGArray::Creator)
+            if defined?(register_array_type) && defined?(PGArray::Creator)
               add_conversion_proc(3909, PGArray::Creator.new("tsrange", procs[3908]))
               add_conversion_proc(3911, PGArray::Creator.new("tstzrange", procs[3910]))
             end

data/lib/sequel/extensions/pg_row.rb

@@ -375,7 +375,7 @@ module Sequel
             @row_schema_types = {}
             extend(@row_type_method_module = Module.new)
             add_conversion_proc(2249, PGRow::Parser.new(:converter=>PGRow::ArrayRow))
-            if respond_to?(:register_array_type)
+            if defined?(register_array_type)
               register_array_type('record', :oid=>2287, :scalar_oid=>2249)
             end
           end
@@ -464,7 +464,7 @@ module Sequel
           parser = Parser.new(parser_opts)
           add_conversion_proc(parser.oid, parser)
 
-          if respond_to?(:register_array_type) && array_oid && array_oid > 0
+          if defined?(register_array_type) && array_oid && array_oid > 0
             array_type_name = if type_schema
               "#{type_schema}.#{type_name}"
             else

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -115,13 +115,13 @@ SQL
       # :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)
+        raise Error, "this database object does not respond to listen, use the postgres adapter with the pg driver" unless defined?(listen)
         models = [models] unless models.is_a?(Array)
         raise Error, "array of models to listen for changes cannot be empty" if models.empty?
 
         oid_map = {}
         models.each do |model|
-          raise Error, "#{model.inspect} does not use the static_cache plugin" unless model.respond_to?(:load_cache)
+          raise Error, "#{model.inspect} does not use the static_cache plugin" unless defined?(model.load_cache)
           oid_map[get(regclass_oid(model.dataset.first_source_table))] = model
         end
 

data/lib/sequel/extensions/symbol_aref.rb

@@ -35,6 +35,7 @@ if RUBY_VERSION >= '2.0'
   class Symbol
     prepend Sequel::SymbolAref
   end
+# :nocov:
 else
   class Symbol
     if method_defined?(:[])
@@ -51,3 +52,4 @@ else
     end
   end
 end
+# :nocov:

data/lib/sequel/model/associations.rb

@@ -1717,6 +1717,8 @@ module Sequel
         # :graph_select :: A column or array of columns to select from the associated table
         #                  when eagerly loading the association via +eager_graph+. Defaults to all
         #                  columns in the associated table.
+        # :instance_specific :: Marks the association as instance specific. Should be used if the association block
+        #                       uses instance specific state, or transient state (accessing current date/time, etc.).
         # :limit :: Limit the number of records to the provided value.  Use
         #           an array with two elements for the value to specify a
         #           limit (first element) and an offset (second element).
@@ -1856,6 +1858,16 @@ module Sequel
             # in certain places to disable optimizations.
             opts[:instance_specific] = _association_instance_specific_default(name)
           end
+          if (orig_opts[:instance_specific] || orig_opts[:dataset]) && !opts.has_key?(:allow_eager) && !opts[:eager_loader]
+            # For associations explicitly marked as instance specific, or that use the
+            # :dataset option, where :allow_eager is not set, and no :eager_loader is
+            # provided, disallow eager loading.  In these cases, eager loading is
+            # unlikely to work.  This is not done for implicit setting of :instance_specific,
+            # because implicit use is done by default for all associations with blocks,
+            # and the vast majority of associations with blocks use the block for filtering
+            # in a manner compatible with eager loading.
+            opts[:allow_eager] = false
+          end
           opts = assoc_class.new.merge!(opts)
 
           if opts[:clone] && !opts.cloneable?(cloned_assoc)
@@ -3004,7 +3016,7 @@ module Sequel
         def complex_expression_sql_append(sql, op, args)
           r = args[1]
           if (((op == :'=' || op == :'!=') && r.is_a?(Sequel::Model)) ||
-              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (r.respond_to?(:all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
+              (multiple = ((op == :IN || op == :'NOT IN') && ((is_ds = r.is_a?(Sequel::Dataset)) || (defined?(r.all?) && r.all?{|x| x.is_a?(Sequel::Model)})))))
             l = args[0]
             if ar = model.association_reflections[l]
               raise Error, "filtering by associations is not allowed for #{ar.inspect}" if ar[:allow_filtering_by] == false
@@ -3012,7 +3024,7 @@ module Sequel
               if multiple
                 klass = ar.associated_class
                 if is_ds
-                  if r.respond_to?(:model)
+                  if defined?(r.model)
                     unless r.model <= klass
                       # A dataset for a different model class, could be a valid regular query
                       return super
@@ -3344,10 +3356,10 @@ module Sequel
           assoc_table_alias = ds.unused_table_alias(alias_base)
           loader = r[:eager_grapher]
           if !associations.empty?
-            if associations.first.respond_to?(:call)
+            if defined?(associations.first.call)
               callback = associations.first
               associations = {}
-            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && pr_assoc.first.respond_to?(:call)
+            elsif associations.length == 1 && (assocs = associations.first).is_a?(Hash) && assocs.length == 1 && (pr_assoc = assocs.to_a.first) && defined?(pr_assoc.first.call)
               callback, assoc = pr_assoc
               associations = assoc.is_a?(Array) ? assoc : [assoc]
             end
@@ -3589,10 +3601,10 @@ module Sequel
             end
           
             associations = eager_assoc[r[:name]]
-            if associations.respond_to?(:call)
+            if defined?(associations.call)
               eager_block = associations
               associations = OPTS
-            elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && pr_assoc.first.respond_to?(:call)
+            elsif associations.is_a?(Hash) && associations.length == 1 && (pr_assoc = associations.to_a.first) && defined?(pr_assoc.first.call)
               eager_block, associations = pr_assoc
             end
 

data/lib/sequel/model/base.rb

@@ -492,13 +492,13 @@ module Sequel
       def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
 
-        if !m.respond_to?(:apply) && !m.respond_to?(:configure) && (!args.empty? || block)
+        if !defined?(m.apply) && !defined?(m.configure) && (!args.empty? || block)
           Deprecation.deprecate("Plugin #{plugin} accepts no arguments or block, and passing arguments/block to it", "Remove arguments and block when loading the plugin")
         end
 
         unless @plugins.include?(m)
           @plugins << m
-          m.apply(self, *args, &block) if m.respond_to?(:apply)
+          m.apply(self, *args, &block) if defined?(m.apply)
           extend(m::ClassMethods) if m.const_defined?(:ClassMethods, false)
           include(m::InstanceMethods) if m.const_defined?(:InstanceMethods, false)
           if m.const_defined?(:DatasetMethods, false)
@@ -506,7 +506,7 @@ module Sequel
           end
         end
 
-        m.configure(self, *args, &block) if m.respond_to?(:configure)
+        m.configure(self, *args, &block) if defined?(m.configure)
       end
       # :nocov:
       ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
@@ -680,10 +680,11 @@ module Sequel
   
       private
       
-      # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
+      # Yield to the passed block and if do_raise is false, swallow Sequel::Errors other than DatabaseConnectionError
+      # and DatabaseDisconnectError.
       def check_non_connection_error(do_raise=require_valid_table)
         db.transaction(:savepoint=>:only){yield}
-      rescue Sequel::DatabaseConnectionError
+      rescue Sequel::DatabaseConnectionError, Sequel::DatabaseDisconnectError
         raise
       rescue Sequel::Error
         raise if do_raise
@@ -693,9 +694,12 @@ module Sequel
       # this model's dataset.
       def convert_input_dataset(ds)
         case ds
-        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, LiteralString
+        when Symbol, SQL::Identifier, SQL::QualifiedIdentifier
           self.simple_table = db.literal(ds).freeze
           ds = db.from(ds)
+        when SQL::AliasedExpression, LiteralString
+          self.simple_table = nil
+          ds = db.from(ds)
         when Dataset
           ds = ds.from_self(:alias=>ds.first_source) if ds.joined_dataset?
 
@@ -784,7 +788,7 @@ module Sequel
         schema_hash = {}
         ds_opts = dataset.opts
         get_columns = proc{check_non_connection_error{columns} || []}
-        schema_array = check_non_connection_error(false){db.schema(dataset, :reload=>reload)} if db.supports_schema_parsing?
+        schema_array = get_db_schema_array(reload) if db.supports_schema_parsing?
         if schema_array
           schema_array.each{|k,v| schema_hash[k] = v}
 
@@ -821,6 +825,12 @@ module Sequel
         schema_hash
       end
 
+      # Get the array of schema information for the dataset.  Returns nil if
+      # the schema information cannot be determined.
+      def get_db_schema_array(reload)
+        check_non_connection_error(false){db.schema(dataset, :reload=>reload)}
+      end
+
       # Uncached version of setter_methods, to be overridden by plugins
       # that want to modify the methods used.
       def get_setter_methods

data/lib/sequel/model/exceptions.rb

@@ -44,7 +44,7 @@ module Sequel
         errors = @model.errors
       end
 
-      if errors.respond_to?(:full_messages)
+      if defined?(errors.full_messages)
         @errors = errors
         super(errors.full_messages.join(', '))
       else

data/lib/sequel/model/inflections.rb

@@ -99,7 +99,7 @@ module Sequel
     # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
     def camelize(s)
       s = s.to_s
-      return s.camelize if s.respond_to?(:camelize)
+      return s.camelize if defined?(s.camelize)
       s = s.gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
       s
     end
@@ -109,7 +109,7 @@ module Sequel
     # or is not initialized.
     def constantize(s)
       s = s.to_s
-      return s.constantize if s.respond_to?(:constantize)
+      return s.constantize if defined?(s.constantize)
       raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.match(s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
@@ -117,14 +117,14 @@ module Sequel
     # Removes the module part from the expression in the string
     def demodulize(s)
       s = s.to_s
-      return s.demodulize if s.respond_to?(:demodulize)
+      return s.demodulize if defined?(s.demodulize)
       s.gsub(/^.*::/, '')
     end
   
     # Returns the plural form of the word in the string.
     def pluralize(s)
       s = s.to_s
-      return s.pluralize if s.respond_to?(:pluralize)
+      return s.pluralize if defined?(s.pluralize)
       result = s.dup
       Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -133,7 +133,7 @@ module Sequel
     # The reverse of pluralize, returns the singular form of a word in a string.
     def singularize(s)
       s = s.to_s
-      return s.singularize if s.respond_to?(:singularize)
+      return s.singularize if defined?(s.singularize)
       result = s.dup
       Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -143,7 +143,7 @@ module Sequel
     # Also changes '::' to '/' to convert namespaces to paths.
     def underscore(s)
       s = s.to_s
-      return s.underscore if s.respond_to?(:underscore)
+      return s.underscore if defined?(s.underscore)
       s.gsub('::', '/').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
         gsub(/([a-z\d])([A-Z])/, '\1_\2').tr('-', '_').downcase
     end

data/lib/sequel/plugins/auto_validations.rb

@@ -252,7 +252,7 @@ module Sequel
 
           unless skip.include?(:unique)
             unique_opts = Hash[opts[:unique]]
-            if model.respond_to?(:sti_dataset)
+            if defined?(model.sti_dataset)
               unique_opts[:dataset] = model.sti_dataset
             end
             model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}

data/lib/sequel/plugins/defaults_setter.rb

@@ -117,7 +117,7 @@ module Sequel
         def [](k)
           if new? && !values.has_key?(k)
             v = model.default_values.fetch(k){return}
-            v = v.call if v.respond_to?(:call)
+            v = v.call if defined?(v.call)
             values[k] = v if model.cache_default_values?
             v
           else

data/lib/sequel/plugins/dirty.rb

@@ -203,7 +203,7 @@ module Sequel
             get_column_value(column)
           end
 
-          initial_values[column] = if value && value != true && value.respond_to?(:clone)
+          initial_values[column] = if value && value != true && defined?(value.clone)
             begin
               value.clone
             rescue TypeError

data/lib/sequel/plugins/insert_conflict.rb

@@ -36,7 +36,7 @@ module Sequel
     module InsertConflict
       def self.configure(model)
         model.instance_exec do
-          if @dataset && !@dataset.respond_to?(:insert_conflict)
+          if @dataset && !defined?(@dataset.insert_conflict)
             raise Error, "#{self}'s dataset does not support insert_conflict"
           end
         end