sequel 4.45.0 → 4.46.0

data/lib/sequel/adapters/utils/pg_types.rb

@@ -5,28 +5,34 @@ module Sequel
     NAN             = 0.0/0.0
     PLUS_INFINITY   = 1.0/0.0
     MINUS_INFINITY  = -1.0/0.0
+
     NAN_STR             = 'NaN'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :NAN_STR)
     PLUS_INFINITY_STR   = 'Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :PLUS_INFINITY_STR)
     MINUS_INFINITY_STR  = '-Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :MINUS_INFINITY_STR)
     TRUE_STR = 't'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRUE_STR)
     DASH_STR = '-'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DASH_STR)
     
     TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == TRUE_STR end
+      def boolean(s) s == 't' end
       def integer(s) s.to_i end
       def float(s) 
         case s
-        when NAN_STR
+        when 'NaN'
           NAN
-        when PLUS_INFINITY_STR
+        when 'Infinity'
           PLUS_INFINITY
-        when MINUS_INFINITY_STR
+        when '-Infinity'
           MINUS_INFINITY
         else
           s.to_f 
         end
       end
-      def date(s) ::Date.new(*s.split(DASH_STR).map(&:to_i)) end
+      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
       def bytea(str)
         str = if str =~ /\A\\x/
           # PostgreSQL 9.0+ bytea hex format
@@ -44,12 +50,14 @@ module Sequel
     # Type OIDs for string types used by PostgreSQL.  These types don't
     # have conversion procs associated with them (since the data is
     # already in the form of a string).
-    STRING_TYPES = [18, 19, 25, 1042, 1043]
+    STRING_TYPES = [18, 19, 25, 1042, 1043]#.freeze # SEQUEL5
 
     # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
     # Non-builtin types that don't have fixed numbers should use this to register
     # conversion procs.
     PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+    PG_NAMED__TYPES = PG_NAMED_TYPES
+    Sequel::Deprecation.deprecate_constant(self, :PG_NAMED_TYPES)
 
     # Hash with integer keys and callable values for converting PostgreSQL types.
     PG_TYPES = {} unless defined?(PG_TYPES)

data/lib/sequel/adapters/utils/replace.rb

@@ -3,8 +3,10 @@
 module Sequel
   class Dataset
     module Replace
-      INSERT = Dataset::INSERT
+      INSERT = 'INSERT'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :INSERT)
       REPLACE = 'REPLACE'.freeze
+      Sequel::Deprecation.deprecate_constant(self, :REPLACE)
 
       # Execute a REPLACE statement on the database (deletes any duplicate
       # rows before inserting).
@@ -31,7 +33,7 @@ module Sequel
 
       # If this is an replace instead of an insert, use replace instead
       def insert_insert_sql(sql)
-        sql << (@opts[:replace] ? REPLACE : INSERT)
+        sql << (@opts[:replace] ? 'REPLACE' : 'INSERT')
       end
     end
   end

data/lib/sequel/connection_pool/single.rb

@@ -16,8 +16,8 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
 
   # Disconnect the connection from the database.
   def disconnect(opts=nil)
-    return unless @conn
-    disconnect_connection(@conn.first)
+    return unless c = @conn.first
+    disconnect_connection(c)
     @conn.clear
     nil
   end

data/lib/sequel/core.rb

@@ -24,7 +24,7 @@
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
-  @split_symbols = true
+  @split_symbols = :deprecated
   @single_threaded = false
 
   class << self
@@ -141,8 +141,8 @@ module Sequel
   # it just loads a module that you can extend other classes with.  Consult the documentation
   # for each extension you plan on using for usage.
   #
-  #   Sequel.extension(:schema_dumper)
-  #   Sequel.extension(:pagination, :query)
+  #   Sequel.extension(:blank)
+  #   Sequel.extension(:core_extensions, :named_timezones)
   def self.extension(*extensions)
     extensions.each{|e| Kernel.require "sequel/extensions/#{e}"}
   end
@@ -228,9 +228,6 @@ module Sequel
     Array(files).each{|f| super("#{File.dirname(__FILE__).untaint}/#{"#{subdir}/" if subdir}#{f}")}
   end
 
-  COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
-  COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
-  COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
   SPLIT_SYMBOL_CACHE = {}
 
   # Splits the symbol into three parts, if symbol splitting is enabled.
@@ -242,13 +239,22 @@ module Sequel
   # For tables, these parts are the schema, table, and alias.
   def self.split_symbol(sym)
     unless v = Sequel.synchronize{SPLIT_SYMBOL_CACHE[sym]}
-      if split_symbols?
+      if split = split_symbols?
         v = case s = sym.to_s
-        when COLUMN_REF_RE1
+        when /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/
+          if split == :deprecated
+            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.qualify(#{$1.inspect}, #{$2.inspect}).as(#{$3.inspect})")
+          end
           [$1.freeze, $2.freeze, $3.freeze].freeze
-        when COLUMN_REF_RE2
+        when /\A((?:(?!___).)+)___(.+)\z/
+          if split == :deprecated
+            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.identifier(#{$1.inspect}).as(#{$2.inspect})")
+          end
           [nil, $1.freeze, $2.freeze].freeze
-        when COLUMN_REF_RE3
+        when /\A((?:(?!__).)+)__(.+)\z/
+          if split == :deprecated
+            Sequel::Deprecation.deprecate("Symbol splitting", "Either set Sequel.split_symbols = true, or change #{sym.inspect} to Sequel.qualify(#{$1.inspect}, #{$2.inspect})")
+          end
           [$1.freeze, $2.freeze, nil].freeze
         else
           [nil, s.freeze, nil].freeze
@@ -399,7 +405,7 @@ module Sequel
   # <tt>SQL::VirtualRow</tt> instance.
   #
   #   Sequel.virtual_row{a} # Sequel::SQL::Identifier.new(:a)
-  #   Sequel.virtual_row{|o| o.a{}} # Sequel::SQL::Function.new(:a)
+  #   Sequel.virtual_row{|o| o.a} # Sequel::SQL::Function.new(:a)
   def self.virtual_row(&block)
     vr = VIRTUAL_ROW
     case block.arity
@@ -452,4 +458,11 @@ module Sequel
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)
+
+  COLUMN_REF_RE1 = /\A((?:(?!__).)+)__((?:(?!___).)+)___(.+)\z/.freeze
+  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE1)
+  COLUMN_REF_RE2 = /\A((?:(?!___).)+)___(.+)\z/.freeze
+  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE2)
+  COLUMN_REF_RE3 = /\A((?:(?!__).)+)__(.+)\z/.freeze
+  Sequel::Deprecation.deprecate_constant(self, :COLUMN_REF_RE3)
 end

data/lib/sequel/database/connecting.rb

@@ -27,7 +27,14 @@ module Sequel
     def self.adapter_class(scheme)
       return scheme if scheme.is_a?(Class)
 
-      scheme = scheme.to_s.gsub('-', '_').to_sym
+      if scheme.to_s.include?('-')
+        # :nocov:
+        Sequel::Deprecation.deprecate("Automatically converting '-' to '_' in adapter schemes", "Use '_' instead of '-' in the adapter scheme")
+        # :nocov:
+      end
+
+      scheme = scheme.to_s.gsub('-', '_').to_sym # SEQUEL5: Remove
+      # scheme = scheme.to_sym # SEQUEL5
 
       load_adapter(scheme)
     end
@@ -204,8 +211,7 @@ module Sequel
     # to be the correct type, so that even if two separate Database objects are
     # using different adapters you can tell that they are using the same database
     # type.  Even better, you can tell that two Database objects that are using
-    # the same adapter are connecting to different database types (think JDBC or
-    # DataObjects).
+    # the same adapter are connecting to different database types.
     #
     #   Sequel.connect('jdbc:postgres://...').database_type # => :postgres
     def database_type

data/lib/sequel/database/dataset_defaults.rb

@@ -9,6 +9,7 @@ module Sequel
 
     # The default class to use for datasets
     DatasetClass = Sequel::Dataset
+    Sequel::Deprecation.deprecate_constant(self, :DatasetClass)
 
     # SEQUEL5: Remove
     @identifier_input_method = nil
@@ -98,7 +99,12 @@ module Sequel
     
     # The default dataset class to use for the database
     def dataset_class_default
-      self.class.const_get(:DatasetClass)
+      if self.class == Sequel::Database
+        Sequel::Dataset
+      else
+        Sequel::Deprecation.deprecate("Using self.class.const_get(:DatasetClass) to get the default dataset class", "Modify the database adapter to implement Database#dataset_class_default")
+        self.class.const_get(:DatasetClass)
+      end
     end
 
     # Reset the default dataset used by most Database methods that

data/lib/sequel/database/logging.rb

@@ -35,6 +35,7 @@ module Sequel
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
     def log_yield(sql, args=nil, &block)
+      Sequel::Deprecation.deprecate("Sequel::Database#log_yield", "Update the adapter to use Sequel::Database#log_connection_yield")
       log_connection_yield(sql, nil, args, &block)
     end
 

data/lib/sequel/database/misc.rb

@@ -151,6 +151,7 @@ module Sequel
       reset_default_dataset
       adapter_initialize
       if typecast_value_boolean(@opts.fetch(:identifier_mangling, true))
+        # SEQUEL5: Remove
         extension(:_deprecated_identifier_mangling)
       end
 
@@ -504,11 +505,13 @@ module Sequel
 
     # Used for checking/removing leading zeroes from strings so they don't get
     # interpreted as octal.
-    LEADING_ZERO_RE = /\A0+(\d)/.freeze
+    LEADING_ZERO_RE = /\A0+(\d)/
+    Sequel::Deprecation.deprecate_constant(self, :LEADING_ZERO_RE)
+
     if RUBY_VERSION >= '1.9'
       # Typecast the value to an Integer
       def typecast_value_integer(value)
-        (value.is_a?(String) && value =~ LEADING_ZERO_RE) ? Integer(value, 10) : Integer(value)
+        (value.is_a?(String) && value =~ /\A0+(\d)/) ? Integer(value, 10) : Integer(value)
       end
     else
     # :nocov:

data/lib/sequel/database/query.rb

@@ -8,9 +8,11 @@ module Sequel
     # ---------------------
 
     STRING_DEFAULT_RE = /\A'(.*)'\z/
-    CURRENT_TIMESTAMP_RE = /now|today|CURRENT|getdate|\ADate\(\)\z/io
-    COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]
-    COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]
+    Sequel::Deprecation.deprecate_constant(self, :STRING_DEFAULT_RE)
+    CURRENT_TIMESTAMP_RE = /now|today|CURRENT|getdate|\ADate\(\)\z/i
+    Sequel::Deprecation.deprecate_constant(self, :CURRENT_TIMESTAMP_RE)
+    COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]#.freeze # SEQUEL5
+    COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]#.freeze # SEQUEL5
 
     # The prepared statement object hash for this database, keyed by name symbol
     attr_reader :prepared_statements
@@ -248,7 +250,7 @@ module Sequel
     # and return the normalized value.
     def column_schema_normalize_default(default, type)
       if column_schema_default_string_type?(type)
-        return unless m = STRING_DEFAULT_RE.match(default)
+        return unless m = /\A'(.*)'\z/.match(default)
         m[1].gsub("''", "'")
       else
         default
@@ -260,7 +262,7 @@ module Sequel
     def column_schema_to_ruby_default(default, type)
       return default unless default.is_a?(String)
       if COLUMN_SCHEMA_DATETIME_TYPES.include?(type)
-        if CURRENT_TIMESTAMP_RE.match(default)
+        if /now|today|CURRENT|getdate|\ADate\(\)\z/i.match(default)
           if type == :date
             return Sequel::CURRENT_DATE
           else

data/lib/sequel/database/schema_generator.rb

@@ -316,6 +316,7 @@ module Sequel
 
     # Alias of CreateTableGenerator for backwards compatibility.
     Generator = CreateTableGenerator
+    Sequel::Deprecation.deprecate_constant(self, :Generator)
   
     # Schema::AlterTableGenerator is an internal class that the user is not expected
     # to instantiate directly.  Instances are created by Database#alter_table.

data/lib/sequel/database/schema_methods.rb

@@ -8,25 +8,33 @@ module Sequel
     # ---------------------
 
     AUTOINCREMENT = 'AUTOINCREMENT'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :AUTOINCREMENT)
     COMMA_SEPARATOR = ', '.freeze
+    Sequel::Deprecation.deprecate_constant(self, :COMMA_SEPARATOR)
     NOT_NULL = ' NOT NULL'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :NOT_NULL)
     NULL = ' NULL'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :NULL)
     PRIMARY_KEY = ' PRIMARY KEY'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :PRIMARY_KEY)
     TEMPORARY = 'TEMPORARY '.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TEMPORARY)
     UNDERSCORE = '_'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNDERSCORE)
     UNIQUE = ' UNIQUE'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNIQUE)
     UNSIGNED = ' UNSIGNED'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :UNSIGNED)
+    DEFAULT_JOIN_TABLE_COLUMN_OPTIONS = {:null=>false}
+    Sequel::Deprecation.deprecate_constant(self, :DEFAULT_JOIN_TABLE_COLUMN_OPTIONS)
 
     # The order of column modifiers to use when defining a column.
-    COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references]
-
-    # The default options for join table columns.
-    DEFAULT_JOIN_TABLE_COLUMN_OPTIONS = {:null=>false}
+    COLUMN_DEFINITION_ORDER = [:collate, :default, :null, :unique, :primary_key, :auto_increment, :references]#.freeze # SEQUEL5
 
     # The alter table operations that are combinable.
     COMBINABLE_ALTER_TABLE_OPS = [:add_column, :drop_column, :rename_column,
       :set_column_type, :set_column_default, :set_column_null,
-      :add_constraint, :drop_constraint]
+      :add_constraint, :drop_constraint]#.freeze # SEQUEL5
 
     # Adds a column to the specified table. This method expects a column name,
     # a datatype and optionally a hash with additional constraints and options:
@@ -75,8 +83,13 @@ module Sequel
     # available for index definition.
     #
     # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc].
-    def alter_table(name, generator=nil, &block)
-      generator ||= alter_table_generator(&block)
+    def alter_table(name, generator=(arg_not_given=true; nil), &block)
+      if generator
+        Sequel::Deprecation.deprecate("Passing a Sequel::Schema::AlterTableGenerator instance as the second argument to Sequel::Database#alter_table ", "Pass a block to Sequel::Database#alter_table instead")
+      else
+        Sequel::Deprecation.deprecate("Passing a second argument to Sequel::Database#alter_table :generator option", "Pass only a single argument to the method") unless arg_not_given
+        generator = alter_table_generator(&block)
+      end
       remove_cached_schema(name)
       apply_alter_table_generator(name, generator)
       nil
@@ -128,7 +141,7 @@ module Sequel
           unless v.is_a?(Hash)
             v = {:table=>v}
           end
-          v = DEFAULT_JOIN_TABLE_COLUMN_OPTIONS.merge(v)
+          v[:null] = false unless v.has_key?(:null)
           foreign_key(key, v)
         end
         primary_key(keys) unless options[:no_primary_key]
@@ -185,10 +198,13 @@ module Sequel
     #             that option names are unquoted, so you should not use untrusted
     #             keys.
     #
-    # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
+    # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
       remove_cached_schema(name)
-      options = {:generator=>options} if options.is_a?(Schema::CreateTableGenerator)
+      if options.is_a?(Schema::CreateTableGenerator)
+        Sequel::Deprecation.deprecate("Passing a Sequel::Schema::CreateTableGenerator instance as the second argument to Sequel::Database#create_table", "Use the Sequel::Database#create_table :generator option instead")
+        options = {:generator=>options}
+      end
       if sql = options[:as]
         raise(Error, "can't provide both :as option and block to create_table") if block
         create_table_as(name, sql, options)
@@ -530,12 +546,12 @@ module Sequel
     # The SQL string specify the autoincrement property, generally used by
     # primary keys.
     def auto_increment_sql
-      AUTOINCREMENT
+      'AUTOINCREMENT'
     end
     
     # The order of the column definition, as an array of symbols.
     def column_definition_order
-      self.class.const_get(:COLUMN_DEFINITION_ORDER)
+      COLUMN_DEFINITION_ORDER
     end
 
     # SQL DDL fragment containing the column creation SQL for the given column.
@@ -572,9 +588,9 @@ module Sequel
 
       case null
       when false
-        sql << NOT_NULL
+        sql << ' NOT NULL'
       when true
-        sql << NULL
+        sql << ' NULL'
       end
     end
     
@@ -584,7 +600,7 @@ module Sequel
         if name = column[:primary_key_constraint_name]
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
-        sql << PRIMARY_KEY
+        sql << ' PRIMARY KEY'
       end
     end
     
@@ -604,13 +620,13 @@ module Sequel
         if name = column[:unique_constraint_name]
           sql << " CONSTRAINT #{quote_identifier(name)}"
         end
-        sql << UNIQUE
+        sql << ' UNIQUE'
       end
     end
     
     # SQL for all given columns, used inside a CREATE TABLE block.
     def column_list_sql(generator)
-      (generator.columns.map{|c| column_definition_sql(c)} + generator.constraints.map{|c| constraint_definition_sql(c)}).join(COMMA_SEPARATOR)
+      (generator.columns.map{|c| column_definition_sql(c)} + generator.constraints.map{|c| constraint_definition_sql(c)}).join(', ')
     end
 
     # SQL DDL fragment for column foreign key references (column constraints)
@@ -622,7 +638,7 @@ module Sequel
     def column_references_sql(column)
       sql = String.new
       sql << " REFERENCES #{quote_schema_table(column[:table])}"
-      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
+      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(', ')})" if column[:key]
       sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
       sql << " ON UPDATE #{on_update_clause(column[:on_update])}" if column[:on_update]
       constraint_deferrable_sql_append(sql, column[:deferrable])
@@ -636,7 +652,6 @@ module Sequel
 
     # Whether the given alter table operation is combinable.
     def combinable_alter_table_op?(op)
-      # Use a dynamic lookup for easier overriding in adapters
       COMBINABLE_ALTER_TABLE_OPS.include?(op[:op])
     end
 
@@ -768,9 +783,8 @@ module Sequel
 
     # Append the column list to the SQL, if a column list is given.
     def create_view_sql_append_columns(sql, columns)
-      sql = sql.dup
       if columns
-        sql << ' ('
+        sql += ' ('
         schema_utility_dataset.send(:identifier_list_append, sql, columns)
         sql << ')'
       end
@@ -781,7 +795,7 @@ module Sequel
     # for certain databases.
     def default_index_name(table_name, columns)
       schema, table = schema_and_table(table_name)
-      "#{"#{schema}_" if schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
+      "#{"#{schema}_" if schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join('_')}_index"
     end
   
     # Get foreign key name for given table and columns.
@@ -807,10 +821,19 @@ module Sequel
     end
 
     # Proxy the filter_expr call to the dataset, used for creating constraints.
+    # Support passing Proc arguments as blocks, as well as treating plain strings
+    # as literal strings, so that previous migrations that used this API do not break.
     def filter_expr(*args, &block)
-      if args.length == 1 && args.first.is_a?(Proc) && !block
-        block = args.first
-        args = nil
+      if args.length == 1
+        arg = args.first
+        if arg.is_a?(Proc) && !block
+          block = args.first
+          args = nil
+        elsif arg.is_a?(String)
+          args = [Sequel.lit(*args)]
+        elsif arg.is_a?(Array) && arg.first.is_a?(String)
+          args = [Sequel.lit(*arg)]
+        end
       end
       schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
     end
@@ -910,7 +933,7 @@ module Sequel
 
     # SQL DDL fragment for temporary table
     def temporary_table_sql
-      self.class.const_get(:TEMPORARY)
+      'TEMPORARY '
     end
 
     # SQL fragment specifying the type of a given column.
@@ -1020,7 +1043,7 @@ module Sequel
       type = "double precision" if type.to_s == 'double'
       column[:size] ||= default_string_column_size if type.to_s == 'varchar'
       elements = column[:size] || column[:elements]
-      "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
+      "#{type}#{literal(Array(elements)) if elements}#{' UNSIGNED' if column[:unsigned]}"
     end
 
     # Whether clob should be used for String :text=>true columns.