sequel 3.47.0 → 3.48.0

data/lib/sequel/adapters/shared/cubrid.rb

@@ -3,6 +3,8 @@ Sequel.require 'adapters/utils/split_alter_table'
 module Sequel
   module Cubrid
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       include Sequel::Database::SplitAlterTable
 
       AUTOINCREMENT = 'AUTO_INCREMENT'.freeze

data/lib/sequel/adapters/shared/db2.rb

@@ -10,6 +10,8 @@ module Sequel
     end
 
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       AUTOINCREMENT = 'GENERATED ALWAYS AS IDENTITY'.freeze
       NOT_NULL      = ' NOT NULL'.freeze
       NULL          = ''.freeze

data/lib/sequel/adapters/shared/firebird.rb

@@ -1,6 +1,8 @@
 module Sequel
   module Firebird
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       AUTO_INCREMENT = ''.freeze
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
 

data/lib/sequel/adapters/shared/informix.rb

@@ -1,6 +1,8 @@
 module Sequel
   module Informix
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       TEMPORARY = 'TEMP '.freeze
 
       # Informix uses the :informix database type

data/lib/sequel/adapters/shared/mssql.rb

@@ -4,6 +4,8 @@ module Sequel
   Dataset::NON_SQL_OPTIONS << :disable_insert_output
   module MSSQL
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
       SERVER_VERSION_RE = /^(\d+)\.(\d+)\.(\d+)/.freeze
       SERVER_VERSION_SQL = "SELECT CAST(SERVERPROPERTY('ProductVersion') AS varchar)".freeze
@@ -21,7 +23,12 @@ module Sequel
       # strings.  True by default for compatibility, can be set to false for a possible
       # performance increase.  This sets the default for all datasets created from this
       # Database object.
-      attr_accessor :mssql_unicode_strings
+      attr_reader :mssql_unicode_strings
+
+      def mssql_unicode_strings=(v)
+        @mssql_unicode_strings = v
+        reset_default_dataset
+      end
 
       # The types to check for 0 scale to transform :decimal types
       # to :integer.
@@ -281,7 +288,7 @@ module Sequel
         m = output_identifier_meth
         metadata_dataset.from(:information_schema__tables___t).
           select(:table_name).
-          filter(:table_type=>type, :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
+          filter(:table_type=>type, :table_schema=>(opts[:schema]||_default_schema||'dbo').to_s).
           map{|x| m.call(x[:table_name])}
       end
 
@@ -343,7 +350,7 @@ module Sequel
               :table_schema => :table_schema, :table_name => :table_name).
          select(:column_name___column, :data_type___db_type, :character_maximum_length___max_chars, :column_default___default, :is_nullable___allow_null, :numeric_precision___column_size, :numeric_scale___scale).
          filter(:c__table_name=>tn)
-        if schema = opts[:schema] || default_schema
+        if schema = opts[:schema] || _default_schema
           ds.filter!(:c__table_schema=>schema)
         end
         ds.map do |row|
@@ -441,12 +448,11 @@ module Sequel
       Sequel::Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
-      attr_accessor :mssql_unicode_strings
+      attr_writer :mssql_unicode_strings
 
-      # Copy the mssql_unicode_strings option from the +db+ object.
-      def initialize(db, opts={})
-        super
-        @mssql_unicode_strings = db.mssql_unicode_strings
+      # Use the database's mssql_unicode_strings setting if the dataset hasn't overridden it.
+      def mssql_unicode_strings
+        defined?(@mssql_unicode_strings) ? @mssql_unicode_strings : (@mssql_unicode_strings = db.mssql_unicode_strings)
       end
 
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.

data/lib/sequel/adapters/shared/mysql.rb

@@ -31,6 +31,8 @@ module Sequel
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
       COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]
@@ -431,6 +433,10 @@ module Sequel
         case db_type
         when /\Aset/io
           :set
+        when /\Amediumint/io
+          :integer
+        when /\Amediumtext/io
+          :string
         else
           super
         end

data/lib/sequel/adapters/shared/oracle.rb

@@ -3,6 +3,8 @@ Sequel.require 'adapters/utils/emulate_offset_with_row_number'
 module Sequel
   module Oracle
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       TEMPORARY = 'GLOBAL TEMPORARY '.freeze
       AUTOINCREMENT = ''.freeze
 

data/lib/sequel/adapters/shared/postgres.rb

@@ -87,6 +87,8 @@ module Sequel
 
     # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       EXCLUDE_SCHEMAS = /pg_*|information_schema/i
       PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
       RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
@@ -488,7 +490,7 @@ module Sequel
       # Options:
       # :qualify :: Return the tables as Sequel::SQL::QualifiedIdentifier instances,
       #             using the schema the table is located in as the qualifier.
-      # :schema :: The schema to search (default_schema by default)
+      # :schema :: The schema to search
       # :server :: The server to use
       def tables(opts={}, &block)
         pg_class_relname('r', opts, &block)
@@ -506,7 +508,7 @@ module Sequel
       # Options:
       # :qualify :: Return the views as Sequel::SQL::QualifiedIdentifier instances,
       #             using the schema the view is located in as the qualifier.
-      # :schema :: The schema to search (default_schema by default)
+      # :schema :: The schema to search
       # :server :: The server to use
       def views(opts={})
         pg_class_relname('v', opts)
@@ -598,6 +600,10 @@ module Sequel
         sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.force_standard_strings))
 
         if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
+          cmm = cmm.to_s.upcase.strip
+          unless VALID_CLIENT_MIN_MESSAGES.include?(cmm)
+            Sequel::Deprecation.deprecate("Using an unsupported client_min_messages setting will raise an Error in Sequel 4.")
+          end
           sqls << "SET client_min_messages = '#{cmm.to_s.upcase}'"
         end
 
@@ -803,7 +809,7 @@ module Sequel
       # If opts includes a :schema option, or a default schema is used, restrict the dataset to
       # that schema.  Otherwise, just exclude the default PostgreSQL schemas except for public.
       def filter_schema(ds, opts)
-        if schema = opts[:schema] || default_schema
+        if schema = opts[:schema] || _default_schema
           ds.filter(:pg_namespace__nspname=>schema.to_s)
         else
           ds.exclude(:pg_namespace__nspname=>EXCLUDE_SCHEMAS)
@@ -1178,8 +1184,12 @@ module Sequel
         else
           sql = 'LOCK TABLE '
           source_list_append(sql, @opts[:from])
+          mode = mode.to_s.upcase.strip
+          unless LOCK_MODES.include?(mode)
+            Sequel::Deprecation.deprecate("Calling Dataset#lock with an unsupported lock mode will raise an Error in Sequel 4.")
+          end
           sql << " IN #{mode} MODE"
-          @db.execute(sql, opts) # lock without a transaction
+          @db.execute(sql, opts)
         end
         nil
       end

data/lib/sequel/adapters/shared/progress.rb

@@ -1,6 +1,7 @@
 module Sequel
   module Progress
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
 
       # Progress uses the :progress database type.
       def database_type

data/lib/sequel/adapters/shared/sqlite.rb

@@ -4,6 +4,8 @@ module Sequel
     # can be used to set PRAGMAs on connections in a thread-safe manner:
     # :auto_vacuum, :foreign_keys, :synchronous, and :temp_store.
     module DatabaseMethods
+      extend Sequel::Database::ResetIdentifierMangling
+
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
@@ -42,10 +44,9 @@ module Sequel
       end
 
       # A symbol signifying the value of the default transaction mode
-      def transaction_mode
-        defined?(@transaction_mode) ? @transaction_mode : (@transaction_mode = nil)
-      end
+      attr_reader :transaction_mode
 
+      # Set the default transaction mode.
       def transaction_mode=(value)
         if TRANSACTION_MODE.include?(value)
           @transaction_mode = value

data/lib/sequel/adapters/sqlite.rb

@@ -91,13 +91,6 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
-      def initialize(opts={})
-        super
-        @conversion_procs = SQLITE_TYPES.dup
-        @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
-        set_integer_booleans
-      end
-      
       # Connect to the database.  Since SQLite is a file based database,
       # the only options available are :database (to specify the database
       # name), and :timeout, to specify how long to wait for the database to
@@ -166,6 +159,12 @@ module Sequel
 
       private
       
+      def adapter_initialize
+        @conversion_procs = SQLITE_TYPES.dup
+        @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
+        set_integer_booleans
+      end
+      
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.
       def _execute(type, sql, opts, &block)

data/lib/sequel/adapters/swift.rb

@@ -10,19 +10,19 @@ module Sequel
     # Contains procs keyed on sub adapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {:postgres=>proc do |db|
-        Sequel.ts_require 'adapters/swift/postgres'
+        Sequel.require 'adapters/swift/postgres'
         db.extend(Sequel::Swift::Postgres::DatabaseMethods)
         db.extend_datasets Sequel::Postgres::DatasetMethods
         db.swift_class = ::Swift::DB::Postgres
       end,
       :mysql=>proc do |db|
-        Sequel.ts_require 'adapters/swift/mysql'
+        Sequel.require 'adapters/swift/mysql'
         db.extend(Sequel::Swift::MySQL::DatabaseMethods)
         db.dataset_class = Sequel::Swift::MySQL::Dataset
         db.swift_class = ::Swift::DB::Mysql
       end,
       :sqlite=>proc do |db|
-        Sequel.ts_require 'adapters/swift/sqlite'
+        Sequel.require 'adapters/swift/sqlite'
         db.extend(Sequel::Swift::SQLite::DatabaseMethods)
         db.dataset_class = Sequel::Swift::SQLite::Dataset
         db.swift_class = ::Swift::DB::Sqlite3
@@ -37,24 +37,6 @@ module Sequel
       # in this database's connection pool will be instances of this class.
       attr_accessor :swift_class
       
-      # Call the DATABASE_SETUP proc directly after initialization,
-      # so the object always uses sub adapter specific code.  Also,
-      # raise an error immediately if the connection doesn't have a
-      # db_type specified, since one is required to include the correct
-      # subadapter.
-      def initialize(opts)
-        super
-        if db_type = opts[:db_type] and !db_type.to_s.empty? 
-          if prok = DATABASE_SETUP[db_type.to_s.to_sym]
-            prok.call(self)
-          else
-            raise(Error, "No :db_type option specified")
-          end
-        else
-          raise(Error, ":db_type option not valid, should be postgres, mysql, or sqlite")
-        end
-      end
-      
       # Create an instance of swift_class for the given options.
       def connect(server)
         opts = server_opts(server)
@@ -101,6 +83,23 @@ module Sequel
       
       private
       
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # db_type specified, since one is required to include the correct
+      # subadapter.
+      def adapter_initialize
+        if db_type = @opts[:db_type] and !db_type.to_s.empty? 
+          if prok = DATABASE_SETUP[db_type.to_s.to_sym]
+            prok.call(self)
+          else
+            raise(Error, "No :db_type option specified")
+          end
+        else
+          raise(Error, ":db_type option not valid, should be postgres, mysql, or sqlite")
+        end
+      end
+      
       # Method to call on a statement object to execute SQL that does
       # not return any rows.
       def connection_execute_method

data/lib/sequel/adapters/swift/mysql.rb

@@ -8,6 +8,7 @@ module Sequel
     module MySQL
       # Database instance methods for MySQL databases accessed via Swift.
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MySQL::DatabaseMethods
         
         private

data/lib/sequel/adapters/swift/postgres.rb

@@ -10,11 +10,13 @@ module Sequel
     module Postgres
       # Methods to add to Database instances that access PostgreSQL via Swift.
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::Postgres::DatabaseMethods
         
         # Add the primary_keys and primary_key_sequences instance variables,
         # so we can get the correct return values for inserted rows.
         def self.extended(db)
+          super
           db.send(:initialize_postgres_adapter)
         end
         

data/lib/sequel/adapters/swift/sqlite.rb

@@ -8,6 +8,7 @@ module Sequel
     module SQLite
       # Database instance methods for SQLite databases accessed via Swift.
       module DatabaseMethods
+        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::SQLite::DatabaseMethods
 
         # Set the correct pragmas on the connection.

data/lib/sequel/adapters/tinytds.rb

@@ -7,12 +7,6 @@ module Sequel
       include Sequel::MSSQL::DatabaseMethods
       set_adapter_scheme :tinytds
 
-      # Choose whether to use unicode strings on initialization
-      def initialize(*)
-        super
-        set_mssql_unicode_strings
-      end
-      
       # Transfer the :user option to the :username option.
       def connect(server)
         opts = server_opts(server)
@@ -94,6 +88,11 @@ module Sequel
 
       private
 
+      # Choose whether to use unicode strings on initialization
+      def adapter_initialize
+        set_mssql_unicode_strings
+      end
+      
       # For some reason, unless you specify a column can be
       # NULL, it assumes NOT NULL, so turn NULL on by default unless
       # the column is a primary key column.

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

@@ -0,0 +1,68 @@
+module Sequel
+  module EmulateOffsetWithReverseAndCount
+    # Make empty? work with an offset with an order.
+    # By default it would break since the order would be based on
+    # a column that empty does not select.
+    def empty?
+      if o = @opts[:offset]
+        unlimited.count <= o
+      else
+        super
+      end
+    end
+
+    # Emulate OFFSET support using reverse order in a subselect, requiring
+    # a count of the number of rows.
+    # 
+    # If offset is used, an order must be provided, since it needs to be
+    # reversed in the subselect.  Note that the order needs to be unambiguous
+    # to work correctly, and you must select all columns that you are ordering on.
+    def select_sql
+      return super unless o = @opts[:offset]
+
+      order = @opts[:order] || default_offset_order
+      if order.nil? || order.empty?
+        raise(Error, "#{db.database_type} requires an order be provided if using an offset")
+      end
+
+      ds = unlimited
+      row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>'').count
+      dsa1 = dataset_alias(1)
+
+      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = Sequel::Dataset::PreparedStatementMethods::PLACEHOLDER_RE.match(o.to_s))
+        # Handle use of bound variable offsets.  Unfortunately, prepared statement
+        # bound variable offsets cannot be handled, since the bound variable value
+        # isn't available until later.
+        s = match[1].to_sym
+        if prepared_arg?(s)
+          o = prepared_arg(s)
+        end
+      end
+
+      reverse_offset = row_count - o
+      ds = if reverse_offset > 0
+        ds.limit(reverse_offset).
+          reverse_order(*order).
+          from_self(:alias=>dsa1).
+          limit(@opts[:limit]).
+          order(*order)
+      else
+        # Sequel doesn't allow a nonpositive limit.  If the offset
+        # is greater than the number of rows, the empty result set
+        # shuld be returned, so use a condition that is always false.
+        ds.where(1=>0)
+      end
+      sql = @opts[:append_sql] || ''
+      subselect_sql_append(sql, ds)
+      sql
+    end
+
+    private
+
+    # The default order to use for datasets with offsets, if no order is defined.
+    # By default, orders by all of the columns in the dataset.
+    def default_offset_order
+      clone(:append_sql=>'', :offset=>nil).columns
+    end
+  end
+end

data/lib/sequel/connection_pool.rb

@@ -42,7 +42,7 @@ class Sequel::ConnectionPool
       when Class
         v.new(db, opts)
       when Symbol
-        Sequel.tsk_require("sequel/connection_pool/#{v}")
+        require("sequel/connection_pool/#{v}")
         connection_pool_class(opts).new(db, opts) || raise(Sequel::Error, "No connection pool class found")
       end
     end