sequel 3.48.0 → 4.0.0

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

@@ -75,7 +75,7 @@ module Sequel
 
       # Return the array of foreign key info hashes using the foreign_key_list PRAGMA,
       # including information for the :on_update and :on_delete entries.
-      def foreign_key_list(table, opts={})
+      def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         h = {}
         metadata_dataset.with_sql("PRAGMA foreign_key_list(?)", input_identifier_meth.call(table)).each do |row|
@@ -90,7 +90,7 @@ module Sequel
       end
 
       # Use the index_list and index_info PRAGMAs to determine the indexes on the table.
-      def indexes(table, opts={})
+      def indexes(table, opts=OPTS)
         m = output_identifier_meth
         im = input_identifier_meth
         indexes = {}
@@ -121,7 +121,7 @@ module Sequel
 
       # Set the integer_booleans option using the passed in :integer_boolean option.
       def set_integer_booleans
-        @integer_booleans = typecast_value_boolean(@opts[:integer_booleans])
+        @integer_booleans = @opts.has_key?(:integer_booleans) ? typecast_value_boolean(@opts[:integer_booleans]) : true
       end
       
       # The version of the server as an integer, where 3.6.19 = 30619.
@@ -161,7 +161,7 @@ module Sequel
       # SQLite supports timezones in timestamps, since it just stores them as strings,
       # but it breaks the usage of SQLite's datetime functions.
       def use_timestamp_timezones?
-        defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = true)
+        defined?(@use_timestamp_timezones) ? @use_timestamp_timezones : (@use_timestamp_timezones = false)
       end
 
       # A symbol signifying the value of the synchronous PRAGMA.
@@ -180,7 +180,7 @@ module Sequel
       #
       # Options:
       # * :server - Set the server to use.
-      def tables(opts={})
+      def tables(opts=OPTS)
         tables_and_views(TABLES_FILTER, opts)
       end
       
@@ -200,7 +200,7 @@ module Sequel
       #
       # Options:
       # * :server - Set the server to use.
-      def views(opts={})
+      def views(opts=OPTS)
         tables_and_views(VIEWS_FILTER, opts)
       end
 
@@ -282,7 +282,7 @@ module Sequel
       end
 
       # A name to use for the backup table
-      def backup_table_name(table, opts={})
+      def backup_table_name(table, opts=OPTS)
         table = table.gsub('`', '')
         (opts[:times]||1000).times do |i|
           table_name = "#{table}_backup#{i}"
@@ -346,7 +346,7 @@ module Sequel
       # Duplicate an existing table by creating a new table, copying all records
       # from the existing table into the new table, deleting the existing table
       # and renaming the new table to the existing table's name.
-      def duplicate_table(table, opts={})
+      def duplicate_table(table, opts=OPTS)
         remove_cached_schema(table)
         def_columns = defined_columns_for(table)
         old_columns = def_columns.map{|c| c[:name]}
@@ -435,7 +435,7 @@ module Sequel
           row.delete(:cid)
           row[:allow_null] = row.delete(:notnull).to_i == 0
           row[:default] = row.delete(:dflt_value)
-          row[:primary_key] = row.delete(:pk).to_i == 1
+          row[:primary_key] = row.delete(:pk).to_i > 0
           row[:default] = nil if blank_object?(row[:default]) || row[:default] == 'NULL'
           row[:db_type] = row.delete(:type)
           row[:type] = schema_column_type(row[:db_type])

data/lib/sequel/adapters/sqlite.rb

@@ -118,19 +118,19 @@ module Sequel
       end
       
       # Run the given SQL with the given arguments and yield each row.
-      def execute(sql, opts={}, &block)
+      def execute(sql, opts=OPTS, &block)
         _execute(:select, sql, opts, &block)
       end
 
       # Run the given SQL with the given arguments and return the number of changed rows.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         _execute(:update, sql, opts)
       end
       
       # Drop any prepared statements on the connection when executing DDL.  This is because
       # prepared statements lock the table in such a way that you can't drop or alter the
       # table while a prepared statement that references it still exists.
-      def execute_ddl(sql, opts={})
+      def execute_ddl(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           conn.prepared_statements.values.each{|cps, s| cps.close}
           conn.prepared_statements.clear
@@ -139,7 +139,7 @@ module Sequel
       end
       
       # Run the given SQL with the given arguments and return the last inserted row id.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         _execute(:insert, sql, opts)
       end
       
@@ -203,10 +203,16 @@ module Sequel
       
       def prepared_statement_argument(arg)
         case arg
-        when Date, DateTime, Time, TrueClass, FalseClass
+        when Date, DateTime, Time
           literal(arg)[1...-1]
         when SQL::Blob
           arg.to_blob
+        when true, false
+          if integer_booleans
+            arg ? 1 : 0
+          else
+            literal(arg)[1...-1]
+          end
         else
           arg
         end
@@ -301,17 +307,17 @@ module Sequel
         
         # Run execute_select on the database with the given SQL and the stored
         # bind arguments.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
+        def execute_dui(sql, opts=OPTS, &block)
           super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
       end
@@ -323,17 +329,17 @@ module Sequel
           
         # Execute the stored prepared statement name and the stored bind
         # arguments instead of the SQL given.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           super(prepared_statement_name, opts, &block)
         end
          
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
+        def execute_dui(sql, opts=OPTS, &block)
           super(prepared_statement_name, opts, &block)
         end
           
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(prepared_statement_name, opts, &block)
         end
       end

data/lib/sequel/adapters/swift.rb

@@ -45,7 +45,7 @@ module Sequel
       end
       
       # Execute the given SQL, yielding a Swift::Result if a block is given.
-      def execute(sql, opts={})
+      def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
             res = log_yield(sql){conn.execute(sql)}
@@ -59,7 +59,7 @@ module Sequel
       
       # Execute the SQL on the this database, returning the number of affected
       # rows.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
             log_yield(sql){conn.execute(sql).affected_rows}
@@ -71,7 +71,7 @@ module Sequel
       
       # Execute the SQL on this database, returning the primary key of the
       # table being inserted to.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
             log_yield(sql){conn.execute(sql).insert_id}

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

@@ -39,7 +39,7 @@ module Sequel
         
         # Use Swift's escape method for quoting.
         def literal_string_append(sql, s)
-          sql << APOS << db.synchronize{|c| c.escape(s)} << APOS
+          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
         end
       end
     end

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

@@ -27,7 +27,7 @@ module Sequel
         
         # Use Swift's escape method for quoting.
         def literal_string_append(sql, s)
-          sql << APOS << db.synchronize{|c| c.escape(s)} << APOS
+          sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(s)} << APOS
         end
       end
     end

data/lib/sequel/adapters/tinytds.rb

@@ -28,7 +28,7 @@ module Sequel
       # +sql+.  The value of such a method is returned to the caller.
       # Otherwise, if a block is given, it is yielded the result object.
       # If no block is given and a :return is not present, +nil+ is returned.
-      def execute(sql, opts={})
+      def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |c|
           begin
             m = opts[:return]
@@ -70,18 +70,18 @@ module Sequel
       end
 
       # Return the number of rows modified by the given +sql+.
-      def execute_dui(sql, opts={})
+      def execute_dui(sql, opts=OPTS)
         execute(sql, opts.merge(:return=>:do))
       end
 
       # Return the value of the autogenerated primary key (if any)
       # for the row inserted by the given +sql+.
-      def execute_insert(sql, opts={})
+      def execute_insert(sql, opts=OPTS)
         execute(sql, opts.merge(:return=>:insert))
       end
 
       # Execute the DDL +sql+ on the database and return nil.
-      def execute_ddl(sql, opts={})
+      def execute_ddl(sql, opts=OPTS)
         execute(sql, opts.merge(:return=>:each))
         nil
       end
@@ -211,17 +211,17 @@ module Sequel
         
         # Run execute_select on the database with the given SQL and the stored
         # bind arguments.
-        def execute(sql, opts={}, &block)
+        def execute(sql, opts=OPTS, &block)
           super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
+        def execute_dui(sql, opts=OPTS, &block)
           super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
         
         # Same as execute, explicit due to intricacies of alias and super.
-        def execute_insert(sql, opts={}, &block)
+        def execute_insert(sql, opts=OPTS, &block)
           super(prepared_sql, {:arguments=>bind_arguments}.merge(opts), &block)
         end
       end
@@ -257,7 +257,7 @@ module Sequel
       # Properly escape the given string +v+.
       def literal_string_append(sql, v)
         sql << (mssql_unicode_strings ? UNICODE_STRING_START : APOS)
-        sql << db.synchronize{|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
+        sql << db.synchronize(@opts[:server]){|c| c.escape(v)}.gsub(BACKSLASH_CRLF_RE, BACKSLASH_CRLF_REPLACE) << APOS
       end
     end
   end

data/lib/sequel/ast_transformer.rb

@@ -157,8 +157,10 @@ module Sequel
     # an instance of one of the +UNBIND_KEY_CLASSES+.
     def bind_key(obj)
       case obj
-      when Symbol, String
+      when Symbol
         obj
+      when String
+        obj.to_sym
       when SQL::Identifier
         bind_key(obj.value)
       when SQL::QualifiedIdentifier

data/lib/sequel/connection_pool.rb

@@ -21,6 +21,8 @@
 # remove_servers(Array of Symbols) :: no longer recognize all shards/servers
 #                                     specified by the array of symbols.
 class Sequel::ConnectionPool
+  OPTS = Sequel::OPTS
+
   # The default server to use
   DEFAULT_SERVER = :default
   
@@ -37,7 +39,7 @@ class Sequel::ConnectionPool
     # option is provided is provided, use that pool class, otherwise
     # use a new instance of an appropriate pool subclass based on the
     # <tt>:single_threaded</tt> and <tt>:servers</tt> options.
-    def get_pool(db, opts = {})
+    def get_pool(db, opts = OPTS)
       case v = connection_pool_class(opts)
       when Class
         v.new(db, opts)
@@ -70,7 +72,7 @@ class Sequel::ConnectionPool
   # :after_connect :: The proc called after each new connection is made, with the
   #                   connection object, useful for customizations that you want to apply to all
   #                   connections.
-  def initialize(db, opts={})
+  def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]
   end

data/lib/sequel/connection_pool/sharded_single.rb

@@ -9,7 +9,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   #   Sequel uses Hash.new(:default).  You can use a hash with a default proc
   #   that raises an error if you want to catch all cases where a nonexistent
   #   server is used.
-  def initialize(db, opts={})
+  def initialize(db, opts=OPTS)
     super
     @conns = {}
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
@@ -38,7 +38,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   # #hold, the connection is reestablished. Options:
   # * :server - Should be a symbol specifing the server to disconnect from,
   #   or an array of symbols to specify multiple servers.
-  def disconnect(opts={})
+  def disconnect(opts=OPTS)
     (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
   end
   

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -13,7 +13,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   #   Sequel uses Hash.new(:default).  You can use a hash with a default proc
   #   that raises an error if you want to catch all cases where a nonexistent
   #   server is used.
-  def initialize(db, opts = {})
+  def initialize(db, opts = OPTS)
     super
     @available_connections = {}
     @connections_to_remove = []
@@ -86,7 +86,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # creates new connections to the database. Options:
   # * :server - Should be a symbol specifing the server to disconnect from,
   #   or an array of symbols to specify multiple servers.
-  def disconnect(opts={})
+  def disconnect(opts=OPTS)
     sync do
       (opts[:server] ? Array(opts[:server]) : @servers.keys).each do |s|
         disconnect_server(s)
@@ -217,10 +217,10 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   # The calling code should already have the mutex before calling this.
   def next_available(server)
     case @connection_handling
-    when :queue
-      available_connections(server).shift
-    else
+    when :stack
       available_connections(server).pop
+    else
+      available_connections(server).shift
     end
   end
   

data/lib/sequel/connection_pool/threaded.rb

@@ -14,15 +14,15 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
   # The following additional options are respected:
   # * :connection_handling - Set how to handle available connections.  By default,
-  #   uses a a stack for performance.  Can be set to :queue to use a queue, which reduces
-  #   the chances of connections becoming stale.
+  #   uses a a queue for fairness.  Can be set to :stack to use a stack, which may
+  #   offer better performance.
   # * :max_connections - The maximum number of connections the connection pool
   #   will open (default 4)
   # * :pool_sleep_time - The amount of time to sleep before attempting to acquire
   #   a connection again (default 0.001)
   # * :pool_timeout - The amount of seconds to wait to acquire a connection
   #   before raising a PoolTimeoutError (default 5)
-  def initialize(db, opts = {})
+  def initialize(db, opts = OPTS)
     super
     @max_size = Integer(opts[:max_connections] || 4)
     raise(Sequel::Error, ':max_connections must be positive') if @max_size < 1
@@ -64,7 +64,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # 
   # Once a connection is requested using #hold, the connection pool
   # creates new connections to the database.
-  def disconnect(opts={})
+  def disconnect(opts=OPTS)
     sync do
       @available_connections.each{|conn| db.disconnect_connection(conn)}
       @available_connections.clear
@@ -163,10 +163,10 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # have the mutex before calling this.
   def next_available
     case @connection_handling
-    when :queue
-      @available_connections.shift
-    else
+    when :stack
       @available_connections.pop
+    else
+      @available_connections.shift
     end
   end
 

data/lib/sequel/core.rb

@@ -17,17 +17,11 @@
 #
 #   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
 #
-# Sequel currently adds methods to the Array, Hash, String and Symbol classes by
-# default.  You can either require 'sequel/no_core_ext' or set the
-# +SEQUEL_NO_CORE_EXTENSIONS+ constant or environment variable before requiring
-# sequel to have Sequel not add methods to those classes.
-#
 # For a more expanded introduction, see the {README}[link:files/README_rdoc.html].
 # For a quicker introduction, see the {cheat sheet}[link:files/doc/cheat_sheet_rdoc.html].
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
-  @empty_array_handle_nulls = true
 
   # Whether Sequel is being run in single threaded mode
   @single_threaded = false
@@ -54,51 +48,6 @@ module Sequel
     # they often implement them differently (e.g. + using seconds on +Time+ and
     # days on +DateTime+).
     attr_accessor :datetime_class
-
-    # Sets whether or not to attempt to handle NULL values correctly when given
-    # an empty array.  By default:
-    #
-    #   DB[:a].filter(:b=>[])
-    #   # SELECT * FROM a WHERE (b != b)
-    #   DB[:a].exclude(:b=>[])
-    #   # SELECT * FROM a WHERE (b = b)
-    #
-    # However, some databases (e.g. MySQL) will perform very poorly
-    # with this type of query.  You can set this to false to get the
-    # following behavior:
-    #
-    #   DB[:a].filter(:b=>[])
-    #   # SELECT * FROM a WHERE 1 = 0
-    #   DB[:a].exclude(:b=>[])
-    #   # SELECT * FROM a WHERE 1 = 1
-    # 
-    # This may not handle NULLs correctly, but can be much faster on
-    # some databases.
-    attr_reader :empty_array_handle_nulls
-
-    def empty_array_handle_nulls=(v)
-      Sequel::Deprecation.deprecate('Sequel.empty_array_handle_nulls=', 'Please switch to loading the empty_array_ignore_nulls plugin if you wish empty array handling to ignore nulls')
-      @empty_array_handle_nulls = v
-    end
-
-    # REMOVE40
-    def virtual_row_instance_eval
-      Sequel::Deprecation.deprecate('Sequel.virtual_row_instance_eval', 'It has no effect, so you can safely stop calling it.')
-    end
-    def virtual_row_instance_eval=(v)
-      Sequel::Deprecation.deprecate('Sequel.virtual_row_instance_eval=', 'It has no effect, so you can safely stop calling it.')
-    end
-    def k_require(*a)
-      Sequel::Deprecation.deprecate('Sequel.k_require', 'Please switch to Kernel.require')
-      Kernel.require(*a)
-    end
-
-    private
-
-    # Make thread safe requiring reentrant to prevent deadlocks.
-    def check_requiring_thread
-      Sequel::Deprecation.deprecate('Sequel.check_requiring_thread', 'It has no effect, so you can safely stop calling it.')
-    end
   end
 
   # Returns true if the passed object could be a specifier of conditions, false otherwise.
@@ -121,6 +70,9 @@ module Sequel
     end
   end
 
+  # Frozen hash used as the default options hash for most options.
+  OPTS = {}.freeze
+
   # Creates a new database object based on the supplied connection string
   # and optional arguments.  The specified scheme determines the database
   # class used, and the rest of the string specifies the connection options.
@@ -368,7 +320,7 @@ module Sequel
   # to uncommit the changes on DB3.  For that kind of support, you need to
   # have two-phase commit/prepared transactions (which Sequel supports on
   # some databases).
-  def self.transaction(dbs, opts={}, &block)
+  def self.transaction(dbs, opts=OPTS, &block)
     unless opts[:rollback]
       rescue_rollback = true
       opts = opts.merge(:rollback=>:reraise)
@@ -385,16 +337,6 @@ module Sequel
     end
   end
 
-  # REMOVE40
-  def self.ts_require(*args)
-    Sequel::Deprecation.deprecate('Sequel.ts_require', 'Please switch to Sequel.require')
-    require(*args)
-  end
-  def self.tsk_require(*args)
-    Sequel::Deprecation.deprecate('Sequel.tsk_require', 'Please switch to Kernel.require')
-    Kernel.require(*args)
-  end
-
   # If the supplied block takes a single argument,
   # yield an <tt>SQL::VirtualRow</tt> instance to the block
   # argument.  Otherwise, evaluate the block in the context of a
@@ -441,11 +383,6 @@ module Sequel
   private_class_method :adapter_method, :def_adapter_method
 
   require(%w"deprecated sql connection_pool exceptions dataset database timezones ast_transformer version")
-  if !defined?(::SEQUEL_NO_CORE_EXTENSIONS) && !ENV.has_key?('SEQUEL_NO_CORE_EXTENSIONS')
-  # :nocov:
-    require(:deprecated_core_extensions)
-  # :nocov:
-  end
 
   # Add the database adapter class methods to Sequel via metaprogramming
   def_adapter_method(*Database::ADAPTERS)