sequel 5.8.0 → 5.9.0

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

@@ -60,7 +60,7 @@ module Sequel
       [17] => tt.method(:bytea),
       [20, 21, 23, 26] => tt.method(:integer),
       [700, 701] => tt.method(:float),
-      [1700] => ::BigDecimal.method(:new),
+      [1700] => ::Kernel.method(:BigDecimal),
       [1083, 1266] => ::Sequel.method(:string_to_time),
       [1082] => ::Sequel.method(:string_to_date),
       [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
@@ -261,7 +261,7 @@ module Sequel
         raise Error, "convert_serial_to_identity is only supported on PostgreSQL 10.2+" unless server_version >= 100002
 
         server = opts[:server]
-        server_hash = server ? {:server=>server} : {}
+        server_hash = server ? {:server=>server} : OPTS
         ds = dataset
         ds = ds.server(server) if server
 
@@ -269,7 +269,7 @@ module Sequel
 
         table_oid = regclass_oid(table)
         im = input_identifier_meth
-        unless column = im.call(opts[:column] || ((sch = schema(table).find{|col, sch| sch[:primary_key] && sch[:auto_increment]}) && sch[0]))
+        unless column = im.call(opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0]))
           raise Error, "could not determine column to convert from serial to identity automatically"
         end
 
@@ -482,6 +482,10 @@ module Sequel
             nsp[:nspname].as(:schema)
           ]}
 
+        if reverse
+          ds = ds.order_append(Sequel[:nsp][:nspname], Sequel[:cl2][:relname])
+        end
+
         h = {}
         fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
 
@@ -1689,8 +1693,8 @@ module Sequel
       end
 
       # Return a clone of the dataset with an addition named window that can be
-      # referenced in window functions. See {SQL::Window} for a list of options
-      # that can be passed in.
+      # referenced in window functions. See Sequel::SQL::Window for a list of
+      # options that can be passed in.
       def window(name, opts)
         clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
       end
@@ -1718,7 +1722,7 @@ module Sequel
 
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
-        to = @opts[:truncate_opts] || {}
+        to = @opts[:truncate_opts] || OPTS
         "TRUNCATE TABLE#{' ONLY' if to[:only]} #{table}#{' RESTART IDENTITY' if to[:restart]}#{' CASCADE' if to[:cascade]}"
       end
 
@@ -1855,6 +1859,12 @@ module Sequel
         sql << ')'
       end
 
+      # Backslash is supported by default as the escape character on PostgreSQL,
+      # and using ESCAPE can break LIKE ANY() usage.
+      def requires_like_escape?
+        false
+      end
+
       # Support FOR SHARE locking when using the :share lock style.
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)

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

@@ -328,7 +328,7 @@ module Sequel
 
       # The array of column schema hashes for the current columns in the table
       def defined_columns_for(table)
-        cols = parse_pragma(table, {})
+        cols = parse_pragma(table, OPTS)
         cols.each do |c|
           c[:default] = LiteralString.new(c[:default]) if c[:default]
           c[:type] = c[:db_type]

data/lib/sequel/adapters/sqlanywhere.rb

@@ -21,7 +21,7 @@ module Sequel
       def blob(s) ::Sequel::SQL::Blob.new(s) end
       def boolean(s) s.to_i != 0 end
       def date(s) ::Date.strptime(s) end
-      def decimal(s) ::BigDecimal.new(s) end
+      def decimal(s) BigDecimal(s) end
       def time(s) ::Sequel.string_to_time(s) end
     end.new
 

data/lib/sequel/adapters/sqlite.rb

@@ -40,7 +40,7 @@ module Sequel
 
       def numeric(s)
         s = s.to_s unless s.is_a?(String)
-        ::BigDecimal.new(s) rescue s
+        BigDecimal(s) rescue s
       end
 
       def time(s)
@@ -181,7 +181,7 @@ module Sequel
             return execute_prepared_statement(conn, type, sql, opts, &block) if sql.is_a?(Symbol)
             log_args = opts[:arguments]
             args = {}
-            opts.fetch(:arguments, {}).each{|k, v| args[k] = prepared_statement_argument(v)}
+            opts.fetch(:arguments, OPTS).each{|k, v| args[k] = prepared_statement_argument(v)}
             case type
             when :select
               log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}

data/lib/sequel/connection_pool.rb

@@ -109,7 +109,8 @@ class Sequel::ConnectionPool
   
   private
 
-  # Remove the connection from the pool.
+  # Remove the connection from the pool.  For threaded connections, this should be
+  # called without the mutex, because the disconnection may block.
   def disconnect_connection(conn)
     db.disconnect_connection(conn)
   end

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -19,6 +19,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     super
     @available_connections = {}
     @connections_to_remove = []
+    @connections_to_disconnect = []
     @servers = opts.fetch(:servers_hash, Hash.new(:default))
     remove_instance_variable(:@waiter)
     @waiters = {}
@@ -130,6 +131,9 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       raise
     ensure
       sync{release(t, conn, server)} if conn
+      while dconn = sync{@connections_to_disconnect.shift}
+        disconnect_connection(dconn)
+      end
     end
   end
 
@@ -201,7 +205,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
 
       # :nocov:
       # It's difficult to get to this point, it can only happen if there is a race condition
-      # where a connection cannot be acquired even after the thread is signalled by the condition
+      # where a connection cannot be acquired even after the thread is signalled by the condition variable
       sync do
         @waiters[server].wait(@mutex, timeout - elapsed)
         if conn = next_available(server)
@@ -227,7 +231,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       end
 
       if (n = _size(server)) >= (max = @max_size)
-        alloc.to_a.each{|t,c| release(t, c, server) unless t.alive?}
+        alloc.to_a.each do |t,c|
+          unless t.alive?
+            remove(t, c, server)
+          end
+        end
         n = nil
       end
 
@@ -339,7 +347,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
       conn = allocated(server).delete(thread)
 
       if @connection_handling == :disconnect
-        disconnect_connection(conn)
+        @connections_to_disconnect << conn
       else
         checkin_connection(server, conn)
       end
@@ -355,6 +363,6 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   def remove(thread, conn, server)
     @connections_to_remove.delete(conn)
     allocated(server).delete(thread) if @servers.include?(server)
-    disconnect_connection(conn)
+    @connections_to_disconnect << conn
   end
 end

data/lib/sequel/connection_pool/threaded.rb

@@ -101,7 +101,12 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       end
       raise
     ensure
-      sync{release(t)} if conn
+      if conn
+        sync{release(t)}
+        if @connection_handling == :disconnect
+          disconnect_connection(conn)
+        end
+      end
     end
   end
 
@@ -150,7 +155,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
 
       # :nocov:
       # It's difficult to get to this point, it can only happen if there is a race condition
-      # where a connection cannot be acquired even after the thread is signalled by the condition
+      # where a connection cannot be acquired even after the thread is signalled by the condition variable
       sync do
         @waiter.wait(@mutex, timeout - elapsed)
         if conn = next_available
@@ -167,15 +172,20 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   # The caller should NOT have the mutex before calling this.
   def assign_connection(thread)
     allocated = @allocated
-
     do_make_new = false
+    to_disconnect = nil
+
     sync do
       if conn = next_available
         return(allocated[thread] = conn)
       end
 
       if (n = _size) >= (max = @max_size)
-        allocated.keys.each{|t| release(t) unless t.alive?}
+        allocated.keys.each do |t|
+          unless t.alive?
+            (to_disconnect ||= []) << @allocated.delete(t)
+          end
+        end
         n = nil
       end
 
@@ -184,6 +194,10 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
       end
     end
 
+    if to_disconnect
+      to_disconnect.each{|dconn| disconnect_connection(dconn)}
+    end
+
     # Connect to the database outside of the connection pool mutex,
     # as that can take a long time and the connection pool mutex
     # shouldn't be locked while the connection takes place.
@@ -252,9 +266,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   def release(thread)
     conn = @allocated.delete(thread)
 
-    if @connection_handling == :disconnect
-      disconnect_connection(conn)
-    else
+    unless @connection_handling == :disconnect
       checkin_connection(conn)
     end
 

data/lib/sequel/core.rb

@@ -384,7 +384,7 @@ module Sequel
   # Helper method that the database adapter class methods that are added to Sequel via
   # metaprogramming use to parse arguments.
   def self.adapter_method(adapter, *args, &block)
-    options = args.last.is_a?(Hash) ? args.pop : {}
+    options = args.last.is_a?(Hash) ? args.pop : OPTS
     opts = {:adapter => adapter.to_sym}
     opts[:database] = args.shift if args.first.is_a?(String)
     if args.any?

data/lib/sequel/database/connecting.rb

@@ -248,6 +248,12 @@ module Sequel
     end
     
     if RUBY_ENGINE == 'ruby' && RUBY_VERSION < '2.5'
+    # :nocov:
+      def synchronize(server=nil)
+        @pool.hold(server || :default){|conn| yield conn}
+      end
+    # :nocov:
+    else
       # Acquires a database connection, yielding it to the passed block. This is
       # useful if you want to make sure the same connection is used for all
       # database queries in the block.  It is also useful if you want to gain
@@ -260,15 +266,9 @@ module Sequel
       #   DB.synchronize do |conn|
       #     # ...
       #   end
-      def synchronize(server=nil)
-        @pool.hold(server || :default){|conn| yield conn}
-      end
-    else
-    # :nocov:
       def synchronize(server=nil, &block)
         @pool.hold(server || :default, &block)
       end
-    # :nocov:
     end
     
     # Attempts to acquire a database connection.  Returns true if successful.

data/lib/sequel/database/misc.rb

@@ -461,12 +461,12 @@ module Sequel
     if RUBY_VERSION >= '2.4'
       # Typecast a string to a BigDecimal
       def _typecast_value_string_to_decimal(value)
-        BigDecimal.new(value)
+        BigDecimal(value)
       end
     else
       # :nocov:
       def _typecast_value_string_to_decimal(value)
-        d = BigDecimal.new(value)
+        d = BigDecimal(value)
         if d.zero?
           # BigDecimal parsing is loose by default, returning a 0 value for
           # invalid input.  If a zero value is received, use Float to check
@@ -488,7 +488,7 @@ module Sequel
       when BigDecimal
         value
       when Numeric
-        BigDecimal.new(value.to_s)
+        BigDecimal(value.to_s)
       when String
         _typecast_value_string_to_decimal(value)
       else

data/lib/sequel/database/query.rb

@@ -32,7 +32,7 @@ module Sequel
     #
     #   DB[:items].where(id: 1).prepare(:first, :sa)
     #   DB.call(:sa) # SELECT * FROM items WHERE id = 1
-    def call(ps_name, hash={}, &block)
+    def call(ps_name, hash=OPTS, &block)
       prepared_statement(ps_name).call(hash, &block)
     end
     
@@ -240,7 +240,7 @@ module Sequel
       when :time
         Sequel.string_to_time(default)
       when :decimal
-        BigDecimal.new(default)
+        BigDecimal(default)
       end
     end
    

data/lib/sequel/database/schema_generator.rb

@@ -67,7 +67,7 @@ module Sequel
             method = type.to_s
           end
 
-          define_method(method){|name, opts={}| column(name, type, opts)}
+          define_method(method){|name, opts=OPTS| column(name, type, opts)}
         end
         nil
       end
@@ -130,10 +130,16 @@ module Sequel
       # :unique :: Mark the column as unique, generally has the same effect as
       #            creating a unique index on the column.
       # :unique_constraint_name :: The name to give the unique key constraint
+      #
+      # MySQL specific options:
+      # :generated_always_as :: Specify a GENERATED ALWAYS AS column expression,
+      #                         if generated columns are supported.
+      # :generated_type :: Set the type of column when using :generated_always_as,
+      #                    should be :virtual or :stored to force a type.
       def column(name, type, opts = OPTS)
         columns << {:name => name, :type => type}.merge!(opts)
         if index_opts = opts[:index]
-          index(name, index_opts.is_a?(Hash) ? index_opts : {})
+          index(name, index_opts.is_a?(Hash) ? index_opts : OPTS)
         end
         nil
       end
@@ -311,7 +317,7 @@ module Sequel
 
       # Add a composite primary key constraint
       def composite_primary_key(columns, *args)
-        opts = args.pop || {}
+        opts = args.pop || OPTS
         constraints << {:type => :primary_key, :columns => columns}.merge!(opts)
         nil
       end

data/lib/sequel/database/schema_methods.rb

@@ -80,7 +80,7 @@ module Sequel
     # Create a join table using a hash of foreign keys to referenced
     # table names.  Example:
     #
-    #   create_join_table:cat_id: :cats, dog_id: :dogs)
+    #   create_join_table(cat_id: :cats, dog_id: :dogs)
     #   # CREATE TABLE cats_dogs (
     #   #  cat_id integer NOT NULL REFERENCES cats,
     #   #  dog_id integer NOT NULL REFERENCES dogs,
@@ -93,6 +93,13 @@ module Sequel
     # key ensures that entries in the table are unique, which is the typical
     # desire for a join table.
     #
+    # The default table name this will create is the sorted version of the two
+    # hash values, joined by an underscore.  So the following two method calls
+    # create the same table:
+    #
+    #   create_join_table(cat_id: :cats, dog_id: :dogs) # cats_dogs
+    #   create_join_table(dog_id: :dogs, cat_id: :cats) # cats_dogs
+    #
     # You can provide column options by making the values in the hash
     # be option hashes, so long as the option hashes have a :table
     # entry giving the table referenced:
@@ -121,7 +128,7 @@ module Sequel
           foreign_key(key, v)
         end
         primary_key(keys) unless options[:no_primary_key]
-        index(keys.reverse, options[:index_options] || {}) unless options[:no_index]
+        index(keys.reverse, options[:index_options] || OPTS) unless options[:no_index]
       end
       nil
     end
@@ -314,7 +321,7 @@ module Sequel
     #   DB.drop_table(:posts, :comments)
     #   DB.drop_table(:posts, :comments, cascade: true)
     def drop_table(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS 
       names.each do |n|
         execute_ddl(drop_table_sql(n, options))
         remove_cached_schema(n)
@@ -329,7 +336,7 @@ module Sequel
     #   # SELECT NULL FROM a LIMIT 1 -- check existence
     #   # DROP TABLE a -- if it already exists
     def drop_table?(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS
       if supports_drop_table_if_exists?
         options = options.merge(:if_exists=>true)
         names.each do |name|
@@ -357,7 +364,7 @@ module Sequel
     # PostgreSQL specific options:
     # :materialized :: Drop a materialized view.
     def drop_view(*names)
-      options = names.last.is_a?(Hash) ? names.pop : {}
+      options = names.last.is_a?(Hash) ? names.pop : OPTS
       names.each do |n|
         execute_ddl(drop_view_sql(n, options))
         remove_cached_schema(n)

data/lib/sequel/dataset/features.rb

@@ -197,6 +197,11 @@ module Sequel
       true
     end
 
+    # Whether the dataset needs ESCAPE for LIKE for correct behavior.
+    def requires_like_escape?
+      true
+    end
+
     # Whether common table expressions are supported in UNION/INTERSECT/EXCEPT clauses.
     def supports_cte_in_compounds?
       supports_cte_in_subqueries?

data/lib/sequel/dataset/misc.rb

@@ -226,7 +226,7 @@ module Sequel
       used_aliases += opts[:join].map{|j| j.table_alias ? alias_alias_symbol(j.table_alias) : alias_symbol(j.table)} if opts[:join]
       if used_aliases.include?(table_alias)
         i = 0
-        loop do
+        while true
           ta = :"#{table_alias}_#{i}"
           return ta unless used_aliases.include?(ta)
           i += 1 

data/lib/sequel/dataset/prepared_statements.rb

@@ -52,7 +52,7 @@ module Sequel
       end
 
       # Set the bind arguments based on the hash and call super.
-      def call(bind_vars={}, &block)
+      def call(bind_vars=OPTS, &block)
         sql = prepared_sql
         prepared_args.freeze
         ps = bind(bind_vars)
@@ -106,7 +106,7 @@ module Sequel
 
       # Sets the prepared_args to the given hash and runs the
       # prepared statement.
-      def call(bind_vars={}, &block)
+      def call(bind_vars=OPTS, &block)
         bind(bind_vars).run(&block)
       end
 
@@ -272,7 +272,7 @@ module Sequel
     #   DB[:table].where(id: :$id).bind(id: 1).call(:first)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def bind(bind_vars={})
+    def bind(bind_vars=OPTS)
       bind_vars = if bv = @opts[:bind_vars]
         Hash[bv].merge!(bind_vars).freeze
       else
@@ -293,7 +293,7 @@ module Sequel
     #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
-    def call(type, bind_variables={}, *values, &block)
+    def call(type, bind_variables=OPTS, *values, &block)
       to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end