sequel 3.47.0 → 3.48.0

data/lib/sequel/database/features.rb

@@ -36,6 +36,17 @@ module Sequel
       supports_create_table_if_not_exists?
     end
 
+    # Whether the database supports Database#foreign_key_list for
+    # parsing foreign keys.
+    def supports_foreign_key_parsing?
+      [:access, :mssql, :mysql, :postgres, :sqlite].include?(database_type)
+    end
+
+    # Whether the database supports Database#indexes for parsing indexes.
+    def supports_index_parsing?
+      [:access, :cubrid, :db2, :mssql, :mysql, :postgres, :sqlite].include?(database_type) || adapter_scheme == :jdbc
+    end
+
     # Whether the database and adapter support prepared transactions
     # (two-phase commit), false by default.
     def supports_prepared_transactions?
@@ -58,6 +69,16 @@ module Sequel
       respond_to?(:schema_parse_table, true)
     end
 
+    # Whether the database supports Database#tables for getting list of tables.
+    def supports_table_listing?
+      [:access, :cubrid, :db2, :firebird, :mssql, :mysql, :oracle, :postgres, :sqlite].include?(database_type) || adapter_scheme == :jdbc
+    end
+    #
+    # Whether the database supports Database#views for getting list of views.
+    def supports_view_listing?
+      supports_table_listing?
+    end
+
     # Whether the database and adapter support transaction isolation levels, false by default.
     def supports_transaction_isolation_levels?
       false

data/lib/sequel/database/misc.rb

@@ -24,6 +24,14 @@ module Sequel
       :time=>Sequel::SQLTime, :boolean=>[TrueClass, FalseClass].freeze, :float=>Float, :decimal=>BigDecimal,
       :blob=>Sequel::SQL::Blob}.freeze
 
+    # Module to be included in shared adapters so that when the DatabaseMethods are
+    # included in the database, the identifier mangling defaults are reset correctly.
+    module ResetIdentifierMangling
+      def extended(obj)
+        obj.send(:reset_identifier_mangling)
+      end
+    end
+
     # Nested hook Proc; each new hook Proc just wraps the previous one.
     @initialize_hook = Proc.new {|db| }
 
@@ -91,7 +99,6 @@ module Sequel
     # options hash.
     #
     # Accepts the following options:
-    # :default_schema :: The default schema to use, see #default_schema.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :identifier_input_method :: A string method symbol to call on identifiers going into the database
     # :identifier_output_method :: A string method symbol to call on identifiers coming from the database
@@ -112,7 +119,7 @@ module Sequel
       @opts[:servers] = {} if @opts[:servers].is_a?(String)
       @opts[:adapter_class] = self.class
       
-      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, @@single_threaded))
+      @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Database.single_threaded))
       @schemas = {}
       @default_schema = @opts.fetch(:default_schema, default_schema_default)
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
@@ -129,6 +136,9 @@ module Sequel
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
       @pool = ConnectionPool.get_pool(self, @opts)
 
+      reset_identifier_mangling
+      adapter_initialize
+
       unless typecast_value_boolean(@opts[:keep_reference]) == false
         Sequel.synchronize{::Sequel::DATABASES.push(self)}
       end
@@ -295,6 +305,10 @@ module Sequel
     
     private
     
+    # Per adapter initialization method, empty by default.
+    def adapter_initialize
+    end
+
     # Returns true when the object is considered blank.
     # The only objects that are blank are nil, false,
     # strings with all whitespace, and ones that respond
@@ -479,7 +493,13 @@ module Sequel
 
     # Typecast the value to a String
     def typecast_value_string(value)
-      value.to_s
+      case value
+      when Hash, Array
+        Sequel::Deprecation.deprecate('Automatically typecasting a hash or array to string for a string column', 'Either typecast the input manually or use the looser_typecasting extension')
+        value.to_s
+      else
+        value.to_s
+      end
     end
 
     # Typecast the value to a Time

data/lib/sequel/database/query.rb

@@ -39,6 +39,7 @@ module Sequel
     # Executes the given SQL on the database. This method should be overridden in descendants.
     # This method should not be called directly by user code.
     def execute(sql, opts={})
+      Sequel::Deprecation.deprecate('Database#execute default implementation and Sequel::NotImplemented', 'All database instances can be assumed to implement execute')
       raise NotImplemented, "#execute should be overridden by adapters"
     end
     
@@ -78,6 +79,7 @@ module Sequel
     # :on_delete :: The action to take ON DELETE
     # :on_update :: The action to take ON UPDATE
     def foreign_key_list(table, opts={})
+      Sequel::Deprecation.deprecate('Database#foreign_key_list default implementation and Sequel::NotImplemented', 'Use Database#supports_foreign_key_parsing? to check for support')
       raise NotImplemented, "#foreign_key_list should be overridden by adapters"
     end
     
@@ -87,7 +89,7 @@ module Sequel
     #   # => 1
     #   DB.get{server_version{}} # SELECT server_version()
     def get(*args, &block)
-      dataset.get(*args, &block)
+      @default_dataset.get(*args, &block)
     end
     
     # Return a hash containing index information for the table. Hash keys are index name symbols.
@@ -100,6 +102,7 @@ module Sequel
     #   DB.indexes(:artists)
     #   # => {:artists_name_ukey=>{:columns=>[:name], :unique=>true}}
     def indexes(table, opts={})
+      Sequel::Deprecation.deprecate('Database#indexes default implementation and Sequel::NotImplemented', 'Use Database#supports_index_parsing? to check for support')
       raise NotImplemented, "#indexes should be overridden by adapters"
     end
     
@@ -219,6 +222,7 @@ module Sequel
     #
     #   DB.tables # => [:albums, :artists]
     def tables(opts={})
+      Sequel::Deprecation.deprecate('Database#tables default implementation and Sequel::NotImplemented', 'Use Database#supports_table_listing? to check for support')
       raise NotImplemented, "#tables should be overridden by adapters"
     end
     
@@ -226,6 +230,7 @@ module Sequel
     #
     #   DB.views # => [:gold_albums, :artists_with_many_albums]
     def views(opts={})
+      Sequel::Deprecation.deprecate('Database#views default implementation and Sequel::NotImplemented', 'Use Database#supports_view_listing? to check for support')
       raise NotImplemented, "#views should be overridden by adapters"
     end
     
@@ -234,7 +239,7 @@ module Sequel
     # Should raise an error if the table doesn't not exist,
     # and not raise an error if the table does exist.
     def _table_exists?(ds)
-      ds.get(Sequel::NULL)
+      ds.get(SQL::AliasedExpression.new(Sequel::NULL, :nil))
     end
     
     # Whether the type should be treated as a string type when parsing the
@@ -312,11 +317,12 @@ module Sequel
     # for this database.  Used when parsing metadata so that column symbols are
     # returned as expected.
     def metadata_dataset
-      return @metadata_dataset if defined?(@metadata_dataset) && @metadata_dataset
-      ds = dataset
-      ds.identifier_input_method = identifier_input_method_default
-      ds.identifier_output_method = identifier_output_method_default
-      @metadata_dataset = ds
+      @metadata_dataset ||= (
+        ds = dataset;
+        ds.identifier_input_method = identifier_input_method_default;
+        ds.identifier_output_method = identifier_output_method_default;
+        ds
+      )
     end
 
     # Return a Method object for the dataset's output_identifier_method.

data/lib/sequel/database/schema_methods.rb

@@ -646,7 +646,7 @@ module Sequel
     # for certain databases.
     def default_index_name(table_name, columns)
       schema, table = schema_and_table(table_name)
-      "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
+      "#{"#{schema}_" if schema and schema != _default_schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
     end
   
     # Get foreign key name for given table and columns.
@@ -752,12 +752,12 @@ module Sequel
       "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
     end
 
-    # Remove the cached schema_utility_dataset, because the identifier
-    # quoting has changed.
+    # REMOVE40
     def reset_schema_utility_dataset
-      @schema_utility_dataset = nil
+      Sequel::Deprecation.deprecate('Database#reset_schema_utility_dataset', 'Switch to Database#reset_default_dataset')
+      reset_default_dataset
     end
-    
+
     # Split the schema information from the table
     def schema_and_table(table_name)
       schema_utility_dataset.schema_and_table(table_name)
@@ -770,7 +770,7 @@ module Sequel
 
     # The dataset to use for proxying certain schema methods.
     def schema_utility_dataset
-      @schema_utility_dataset ||= dataset
+      @default_dataset
     end
 
     # Split the schema information from the table

data/lib/sequel/database/transactions.rb

@@ -74,6 +74,7 @@ module Sequel
     #                 and :remote_write (9.2+).
     def transaction(opts={}, &block)
       if opts[:disconnect] == :retry
+        Sequel::Deprecation.deprecate('Database#transaction :disconnect=>:retry option', 'Please switch to :retry_on=>Sequel::DatabaseDisconnectError.')
         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

data/lib/sequel/dataset/actions.rb

@@ -14,6 +14,7 @@ module Sequel
       map max min multi_insert paged_each range select_hash select_hash_groups select_map select_order_map
       set single_record single_value sum to_csv to_hash to_hash_groups truncate update
     METHS
+    # REMOVE40 []= insert_multiple set to_csv
 
     # Inserts the given argument into the database.  Returns self so it
     # can be used safely when chaining:
@@ -39,6 +40,7 @@ module Sequel
     #   DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
     #   # => 1 # number of rows affected
     def []=(conditions, values)
+      Sequel::Deprecation.deprecate('Dataset#[]=', 'Please load the sequel_3_dataset_methods extension to continue using it')
       filter(conditions).update(values)
     end
 
@@ -66,7 +68,7 @@ module Sequel
     #   DB[:table].avg{function(column)} # SELECT avg(function(column)) FROM table LIMIT 1
     #   # => 1
     def avg(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{avg(column)}
+      aggregate_dataset.get{avg(column).as(:avg)}
     end
   
     # Returns the columns in the result set in order as an array of symbols.
@@ -101,24 +103,24 @@ module Sequel
     # treated as a virtual row, and the result is used as the argument to
     # count.
     #
-    #   DB[:table].count # SELECT COUNT(*) AS count FROM table LIMIT 1
+    #   DB[:table].count # SELECT count(*) AS count FROM table LIMIT 1
     #   # => 3
-    #   DB[:table].count(:column) # SELECT COUNT(column) AS count FROM table LIMIT 1
+    #   DB[:table].count(:column) # SELECT count(column) AS count FROM table LIMIT 1
     #   # => 2
-    #   DB[:table].count{foo(column)} # SELECT COUNT(foo(column)) AS count FROM table LIMIT 1
+    #   DB[:table].count{foo(column)} # SELECT count(foo(column)) AS count FROM table LIMIT 1
     #   # => 1
     def count(arg=(no_arg=true), &block)
       if no_arg
         if block
           arg = Sequel.virtual_row(&block)
-          aggregate_dataset.get{COUNT(arg).as(count)}
+          aggregate_dataset.get{count(arg).as(count)}
         else
-          aggregate_dataset.get{COUNT(:*){}.as(count)}.to_i
+          aggregate_dataset.get{count(:*){}.as(count)}.to_i
         end
       elsif block
         raise Error, 'cannot provide both argument and block to Dataset#count'
       else
-        aggregate_dataset.get{COUNT(arg).as(count)}
+        aggregate_dataset.get{count(arg).as(count)}
       end
     end
     
@@ -144,11 +146,11 @@ module Sequel
     # Note that this method is not safe to use on many adapters if you are
     # running additional queries inside the provided block.  If you are
     # running queries inside the block, you should use +all+ instead of +each+
-    # for the outer queries, or use a separate thread or shard inside +each+:
+    # for the outer queries, or use a separate thread or shard inside +each+.
     def each
       if @opts[:graph]
         graph_each{|r| yield r}
-      elsif defined?(@row_proc) && (row_proc = @row_proc)
+      elsif row_proc = @row_proc
         fetch_rows(select_sql){|r| yield row_proc.call(r)}
       else
         fetch_rows(select_sql){|r| yield r}
@@ -169,6 +171,7 @@ module Sequel
     # This method should probably should not be called by user code, use +each+
     # instead.
     def fetch_rows(sql)
+      Sequel::Deprecation.deprecate('Dataset#fetch_rows default implementation and Sequel::NotImplemented', 'All dataset instances can be assumed to implement fetch_rows')
       raise NotImplemented, NOTIMPL_MSG
     end
     
@@ -214,7 +217,7 @@ module Sequel
         ds.single_record
       else
         args = (args.size == 1) ? args.first : args
-        if Integer === args
+        if args.is_a?(Integer)
           ds.limit(args).all
         else
           ds.filter(args).single_record
@@ -263,7 +266,7 @@ module Sequel
 
       if column.is_a?(Array)
        if r = ds.single_record
-         r.values_at(*column.map{|c| hash_key_symbol(c)})
+         r.values_at(*hash_key_symbols(column))
        end
       else
         ds.single_value
@@ -373,6 +376,7 @@ module Sequel
     #   # INSERT INTO table (x, y) VALUES (1, 2)
     #   # INSERT INTO table (x, y) VALUES (2, 4)
     def insert_multiple(array, &block)
+      Sequel::Deprecation.deprecate('Dataset#insert_multiple', 'Please load the sequel_3_dataset_methods extension to continue using it')
       if block
         array.map{|i| insert(block.call(i))}
       else
@@ -388,7 +392,7 @@ module Sequel
     #   DB[:table].interval{function(column)} # SELECT (max(function(column)) - min(function(column))) FROM table LIMIT 1
     #   # => 7
     def interval(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{max(column) - min(column)}
+      aggregate_dataset.get{(max(column) - min(column)).as(:interval)}
     end
 
     # Reverses the order and then runs #first with the given arguments and block.  Note that this
@@ -442,7 +446,7 @@ module Sequel
     #   DB[:table].max{function(column)} # SELECT max(function(column)) FROM table LIMIT 1
     #   # => 7
     def max(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{max(column)}
+      aggregate_dataset.get{max(column).as(:max)}
     end
 
     # Returns the minimum value for the given column/expression.
@@ -453,7 +457,7 @@ module Sequel
     #   DB[:table].min{function(column)} # SELECT min(function(column)) FROM table LIMIT 1
     #   # => 0
     def min(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{min(column)}
+      aggregate_dataset.get{min(column).as(:min)}
     end
 
     # This is a front end for import that allows you to submit an array of
@@ -621,6 +625,7 @@ module Sequel
     # Alias for update, but not aliased directly so subclasses
     # don't have to override both methods.
     def set(*args)
+      Sequel::Deprecation.deprecate('Dataset#set', 'Please switch to Dataset#update or load the sequel_3_dataset_methods extension to continue using it')
       update(*args)
     end
     
@@ -649,7 +654,7 @@ module Sequel
     #   DB[:table].sum{function(column)} # SELECT sum(function(column)) FROM table LIMIT 1
     #   # => 10
     def sum(column=Sequel.virtual_row(&Proc.new))
-      aggregate_dataset.get{sum(column)}
+      aggregate_dataset.get{sum(column).as(:sum)}
     end
 
     # Returns a string in CSV format containing the dataset records. By 
@@ -666,6 +671,7 @@ module Sequel
     #   # 1,Jim
     #   # 2,Bob
     def to_csv(include_column_titles = true)
+      Sequel::Deprecation.deprecate('Dataset#to_csv', 'Please load the sequel_3_dataset_methods extension to continue using it')
       n = naked
       cols = n.columns
       csv = ''
@@ -824,17 +830,8 @@ module Sequel
     
     # Internals of +select_hash+ and +select_hash_groups+
     def _select_hash(meth, key_column, value_column)
-      if key_column.is_a?(Array)
-        if value_column.is_a?(Array)
-          select(*(key_column + value_column)).send(meth, key_column.map{|c| hash_key_symbol(c)}, value_column.map{|c| hash_key_symbol(c)})
-        else
-          select(*(key_column + [value_column])).send(meth, key_column.map{|c| hash_key_symbol(c)}, hash_key_symbol(value_column))
-        end
-      elsif value_column.is_a?(Array)
-        select(key_column, *value_column).send(meth, hash_key_symbol(key_column), value_column.map{|c| hash_key_symbol(c)})
-      else
-        select(key_column, value_column).send(meth, hash_key_symbol(key_column), hash_key_symbol(value_column))
-      end
+      select(*(key_column.is_a?(Array) ? key_column : [key_column]) + (value_column.is_a?(Array) ? value_column : [value_column])).
+        send(meth, hash_key_symbols(key_column), hash_key_symbols(value_column))
     end
     
     # Internals of +select_map+ and +select_order_map+
@@ -846,7 +843,7 @@ module Sequel
       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)})
+        ds._select_map_multiple(hash_key_symbols(select_cols))
       else
         ds._select_map_single
       end
@@ -881,28 +878,44 @@ module Sequel
     
     # Return a plain symbol given a potentially qualified or aliased symbol,
     # specifying the symbol that is likely to be used as the hash key
-    # for the column when records are returned.
-    def hash_key_symbol(s, recursing=false)
+    # for the column when records are returned.  Return nil if no hash key
+    # can be determined
+    def _hash_key_symbol(s, recursing=false)
       case s
       when Symbol
         _, c, a = split_symbol(s)
         (a || c).to_sym
       when SQL::Identifier, SQL::Wrapper
-        hash_key_symbol(s.value, true)
+        _hash_key_symbol(s.value, true)
       when SQL::QualifiedIdentifier
-        hash_key_symbol(s.column, true)
+        _hash_key_symbol(s.column, true)
       when SQL::AliasedExpression
-        hash_key_symbol(s.aliaz, true)
+        _hash_key_symbol(s.aliaz, true)
       when String
-        if recursing
-          s.to_sym
-        else
-          raise(Error, "#{s.inspect} is not supported, should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression") 
-        end
+        s.to_sym if recursing
+      end
+    end
+
+    # Return a plain symbol given a potentially qualified or aliased symbol,
+    # specifying the symbol that is likely to be used as the hash key
+    # for the column when records are returned.  Raise Error if the hash key
+    # symbol cannot be returned.
+    def hash_key_symbol(s)
+      if v = _hash_key_symbol(s)
+        v
+      elsif block_given?
+        yield
       else
-        raise(Error, "#{s.inspect} is not supported, should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression") 
+        raise(Error, "#{s.inspect} is not supported, should be a Symbol, SQL::Identifier, SQL::QualifiedIdentifier, or SQL::AliasedExpression")
       end
     end
+
+    # If s is an array, return an array with the given hash key symbols.
+    # Otherwise, return a hash key symbol for the given expression 
+    # If a hash key symbol cannot be determined, raise an error.
+    def hash_key_symbols(s)
+      s.is_a?(Array) ? s.map{|c| hash_key_symbol(c)} : hash_key_symbol(s)
+    end
     
     # Modify the identifier returned from the database based on the
     # identifier_output_method.