sequel 4.42.1 → 4.43.0

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -103,6 +103,11 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
     end
   end
   
+  def freeze
+    @servers.freeze
+    super
+  end
+  
   # Chooses the first available connection to the given server, or if none are
   # available, creates a new connection.  Passes the connection to the supplied
   # block:

data/lib/sequel/connection_pool/single.rb

@@ -4,22 +4,31 @@
 # It is just a wrapper around a single connection that uses the connection pool
 # API.
 class Sequel::SingleConnectionPool < Sequel::ConnectionPool  
+  def initialize(db, opts=OPTS)
+    super
+    @conn = []
+  end
+
   # Yield the connection if one has been made.
   def all_connections
-    yield @conn if @conn
+    yield @conn.first if @conn
   end
 
   # Disconnect the connection from the database.
   def disconnect(opts=nil)
     return unless @conn
-    disconnect_connection(@conn)
-    @conn = nil
+    disconnect_connection(@conn.first)
+    @conn.clear
+    nil
   end
-  
+
   # Yield the connection to the block.
   def hold(server=nil)
     begin
-      yield(@conn ||= make_new(DEFAULT_SERVER))
+      unless c = @conn.first
+        @conn.replace([c = make_new(DEFAULT_SERVER)])
+      end
+      yield c
     rescue Sequel::DatabaseDisconnectError, *@error_classes => e
       disconnect if disconnect_error?(e)
       raise
@@ -38,7 +47,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   # The SingleConnectionPool always has a size of 1 if connected
   # and 0 if not.
   def size
-    @conn ? 1 : 0
+    @conn.empty? ? 0 : 1
   end
 
   private

data/lib/sequel/database/dataset.rb

@@ -43,6 +43,9 @@ module Sequel
     # injection:
     #
     #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).all
+    #
+    # See caveats listed in Dataset#with_sql regarding datasets using custom
+    # SQL and the methods that can be called on them.
     def fetch(sql, *args, &block)
       ds = @default_dataset.with_sql(sql, *args)
       ds.each(&block) if block

data/lib/sequel/database/misc.rb

@@ -138,6 +138,7 @@ module Sequel
       @dataset_class = dataset_class_default
       @cache_schema = typecast_value_boolean(@opts.fetch(:cache_schema, true))
       @dataset_modules = []
+      @loaded_extensions = []
       @schema_type_classes = SCHEMA_TYPE_CLASSES.dup
 
       self.sql_log_level = @opts[:sql_log_level] ? @opts[:sql_log_level].to_sym : :info
@@ -162,6 +163,23 @@ module Sequel
       end
     end
 
+    # Freeze internal data structures for the Database instance.
+    def freeze
+      valid_connection_sql
+      metadata_dataset
+      @opts.freeze
+      @loggers.freeze
+      @pool.freeze
+      @dataset_class.freeze
+      @dataset_modules.freeze
+      @schema_type_classes.freeze
+      @loaded_extensions.freeze
+      # SEQUEL5: Frozen by default, remove this
+      @default_dataset.freeze
+      metadata_dataset.freeze
+      super
+    end
+
     # Cast the given type to a literal type
     #
     #   DB.cast_type_literal(Float) # double precision
@@ -179,7 +197,10 @@ module Sequel
       Sequel.extension(*exts)
       exts.each do |ext|
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          pr.call(self)
+          unless Sequel.synchronize{@loaded_extensions.include?(ext)}
+            Sequel.synchronize{@loaded_extensions << ext}
+            pr.call(self)
+          end
         else
           raise(Error, "Extension #{ext} does not have specific support handling individual databases (try: Sequel.extension #{ext.inspect})")
         end

data/lib/sequel/database/query.rb

@@ -308,10 +308,8 @@ module Sequel
 
     # Remove the cached schema for the given schema name
     def remove_cached_schema(table)
-      if @schemas
-        k = quote_schema_table(table)
-        Sequel.synchronize{@schemas.delete(k)}
-      end
+      k = quote_schema_table(table)
+      Sequel.synchronize{@schemas.delete(k)}
     end
     
     # Match the database's column type to a ruby type via a

data/lib/sequel/dataset/actions.rb

@@ -848,7 +848,6 @@ module Sequel
     # :hash :: The object into which the values will be placed.  If this is not
     #          given, an empty hash is used.  This can be used to use a hash with
     #          a default value or default proc.
-    # to start with a new, empty hash.
     def to_hash_groups(key_column, value_column = nil, opts = OPTS)
       h = opts[:hash] || {}
       meth = opts[:all] ? :all : :each

data/lib/sequel/dataset/misc.rb

@@ -91,14 +91,12 @@ module Sequel
       end
     else
       # :nocov:
-      # :nodoc:
-      def freeze
+      def freeze # :nodoc:
         @opts.freeze
         self
       end
 
-      # :nodoc:
-      def frozen?
+      def frozen?  # :nodoc:
         @opts.frozen?
       end
       # :nocov:

data/lib/sequel/dataset/query.rb

@@ -96,8 +96,7 @@ module Sequel
       end
     else
       # :nocov:
-      # :nodoc:
-      def clone(opts = OPTS)
+      def clone(opts = OPTS) # :nodoc:
         c = super()
         c.opts.merge!(opts)
         unless opts.each_key{|o| break if COLUMN_CHANGE_OPTS.include?(o)}
@@ -204,8 +203,7 @@ module Sequel
       end
     else
       # :nocov:
-      # :nodoc:
-      def extension(*exts)
+      def extension(*exts) # :nodoc:
         c = clone
         c.send(:_extension!, exts)
         c
@@ -1085,8 +1083,7 @@ module Sequel
       end
     else
       # :nocov:
-      # :nodoc:
-      def with_extend(*mods, &block)
+      def with_extend(*mods, &block) # :nodoc:
         c = clone
         c.extend(*mods) unless mods.empty?
         c.extend(Module.new(&block)) if block
@@ -1116,6 +1113,26 @@ module Sequel
     # You can also provide a method name and arguments to call to get the SQL:
     #
     #   DB[:items].with_sql(:insert_sql, :b=>1) # INSERT INTO items (b) VALUES (1)
+    #
+    # Note that datasets that specify custom SQL using this method will generally
+    # ignore future dataset methods that modify the SQL used, as specifying custom SQL
+    # overrides Sequel's SQL generator.  You should probably limit yourself to the following
+    # dataset methods when using this method:
+    #
+    # * each
+    # * all
+    # * single_record (if only one record could be returned)
+    # * single_value (if only one record could be returned, and a single column is selected)
+    # * map
+    # * to_hash
+    # * delete (if a DELETE statement)
+    # * update (if an UPDATE statement, with no arguments)
+    # * insert (if an INSERT statement, with no arguments)
+    # * truncate (if a TRUNCATE statement, with no arguments)
+    #
+    # If you want to use arbitrary dataset methods on a dataset that uses custom SQL, call
+    # from_self on the dataset, which wraps the custom SQL in a subquery, and allows normal
+    # dataset methods that modify the SQL to work.
     def with_sql(sql, *args)
       if sql.is_a?(Symbol)
         sql = send(sql, *args)

data/lib/sequel/extensions/_model_constraint_validations.rb

@@ -0,0 +1,16 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module ConstraintValidations
+      module DatabaseMethods
+        # A hash of validation method call metadata for all tables in the database.
+        # The hash is keyed by table name string and contains arrays of validation
+        # method call arrays.
+        attr_accessor :constraint_validations
+      end
+    end
+  end
+
+  Database.register_extension(:_model_constraint_validations, Plugins::ConstraintValidations::DatabaseMethods)
+end

data/lib/sequel/extensions/_model_pg_row.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    module PgRow
+      module DatabaseMethods
+        ESCAPE_RE = /("|\\)/.freeze
+        ESCAPE_REPLACEMENT = '\\\\\1'.freeze
+        COMMA = ','
+
+        # Handle Sequel::Model instances in bound variables.
+        def bound_variable_arg(arg, conn)
+          case arg
+          when Sequel::Model
+            "(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA)})"
+          else
+            super
+          end
+        end
+
+        # If a Sequel::Model instance is given, return it as-is
+        # instead of attempting to convert it.
+        def row_type(db_type, v)
+          if v.is_a?(Sequel::Model)
+            v
+          else
+            super
+          end
+        end
+
+        private
+
+        # Handle Sequel::Model instances in bound variable arrays.
+        def bound_variable_array(arg)
+          case arg
+          when Sequel::Model
+            "\"(#{arg.values.values_at(*arg.columns).map{|v| bound_variable_array(v)}.join(COMMA).gsub(ESCAPE_RE, ESCAPE_REPLACEMENT)})\""
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+
+  Database.register_extension(:_model_pg_row, Plugins::PgRow::DatabaseMethods)
+end

data/lib/sequel/extensions/looser_typecasting.rb

@@ -41,9 +41,11 @@ module Sequel
         BigDecimal.new('0.0')
       end
     else
+      # :nocov:
       def _typecast_value_string_to_decimal(value)
         BigDecimal.new(value)
       end
+      # :nocov:
     end
   end
 

data/lib/sequel/extensions/migration.rb

@@ -760,7 +760,18 @@ module Sequel
       c = column
       ds = db.from(table)
       if !db.table_exists?(table)
-        db.create_table(table){String c, :primary_key=>true}
+        begin
+          db.create_table(table){String c, :primary_key=>true}
+        rescue Sequel::DatabaseError => e
+          if db.database_type == :mysql && e.message =~ /max key length/
+            # Handle case where MySQL is used with utf8mb4 charset default, which
+            # only allows a maximum length of about 190 characters for string
+            # primary keys due to InnoDB limitations.
+            db.create_table(table){String c, :primary_key=>true, :size=>190}
+          else
+            raise e
+          end
+        end
         if db.table_exists?(:schema_info) and vha = db[:schema_info].all and vha.length == 1 and
            vha.first.keys == [:version] and vha.first.values.first.is_a?(Integer)
           convert_from_schema_info

data/lib/sequel/extensions/pg_array.rb

@@ -221,6 +221,12 @@ module Sequel
           end
         end
 
+        # Freeze the pg array schema types to prevent adding new ones.
+        def freeze
+          @pg_array_schema_types.freeze
+          super
+        end
+
         # Register a database specific array type.  This can be used to support
         # different array types per Database.  Use of this method does not
         # affect global state, unlike PGArray.register.  See PGArray.register for

data/lib/sequel/extensions/pg_enum.rb

@@ -111,7 +111,8 @@ module Sequel
       def parse_enum_labels
         @enum_labels = metadata_dataset.from(:pg_enum).
           order(:enumtypid, :enumsortorder).
-          select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel)
+          select_hash_groups(Sequel.cast(:enumtypid, Integer).as(:v), :enumlabel).freeze
+        @enum_labels.each_value(&:freeze)
 
         if respond_to?(:register_array_type)
           array_types = metadata_dataset.

data/lib/sequel/extensions/pg_range.rb

@@ -269,6 +269,12 @@ module Sequel
           end
         end
 
+        # Freeze the pg range schema types to prevent adding new ones.
+        def freeze
+          @pg_range_schema_types.freeze
+          super
+        end
+
         # Register a database specific range type.  This can be used to support
         # different range types per Database.  Use of this method does not
         # affect global state, unlike PGRange.register.  See PGRange.register for

data/lib/sequel/extensions/pg_row.rb

@@ -411,6 +411,14 @@ module Sequel
           end
         end
 
+        # Freeze the row types and row schema types to prevent adding new ones.
+        def freeze
+          @row_types.freeze
+          @row_schema_types.freeze
+          @row_type_method_module.freeze
+          super
+        end
+
         # Register a new row type for the Database instance. db_type should be the type
         # symbol.  This parses the PostgreSQL system tables to get information the
         # composite type, and by default has the type return instances of a subclass

data/lib/sequel/model/associations.rb

@@ -2119,8 +2119,10 @@ module Sequel
         # retrieving associations after freezing will still work in most cases,
         # but the associations will not be cached in the association cache.
         def freeze
-          associations.freeze
+          associations
           super
+          associations.freeze
+          self
         end
       
         private

data/lib/sequel/model/base.rb

@@ -32,6 +32,10 @@ module Sequel
       # model instances, or nil if the optimization should not be used. For internal use only.
       attr_reader :fast_instance_delete_sql
 
+      # SQL string fragment used for faster lookups by primary key, or nil if the optimization
+      # should not be used. For internal use only.
+      attr_reader :fast_pk_lookup_sql
+
       # The dataset that instance datasets (#this) are based on.  Generally a naked version of
       # the model's dataset limited to one row.  For internal use only.
       attr_reader :instance_dataset
@@ -416,8 +420,8 @@ module Sequel
       #   Artist.by_name.where(:name.like('A%'))
       #
       #   # Just add a class method that calls an existing dataset method
-      #   Artist.def_dataset_method(:server!)
-      #   Artist.server!(:server1)
+      #   Artist.def_dataset_method(:paginate)
+      #   Artist.paginate(2, 10)
       def def_dataset_method(*args, &block)
         raise(Error, "No arguments given") if args.empty?
 
@@ -2038,7 +2042,14 @@ module Sequel
 
       # Get the row of column data from the database.
       def _refresh_get(dataset)
-        dataset.first
+        if (sql = (m = model).fast_pk_lookup_sql) && !dataset.opts[:lock]
+          sql = sql.dup
+          ds = use_server(dataset)
+          ds.literal_append(sql, pk)
+          ds.with_sql_first(sql)
+        else
+          dataset.first
+        end
       end
       
       # Set the refreshed values after 

data/lib/sequel/plugins/constraint_validations.rb

@@ -72,13 +72,6 @@ module Sequel
         end
       end
 
-      module DatabaseMethods
-        # A hash of validation method call metadata for all tables in the database.
-        # The hash is keyed by table name string and contains arrays of validation
-        # method call arrays.
-        attr_accessor :constraint_validations
-      end
-
       module ClassMethods
         # An array of validation method call arrays.  Each array is an array that
         # is splatted to send to perform a validation via validation_helpers.
@@ -106,7 +99,7 @@ module Sequel
         # If this model has associated dataset, use the model's table name
         # to get the validations for just this model.
         def parse_constraint_validations
-          db.extend(DatabaseMethods)
+          db.extension(:_model_constraint_validations)
 
           unless hash = Sequel.synchronize{db.constraint_validations}
             hash = {}

data/lib/sequel/plugins/instance_filters.rb

@@ -124,7 +124,7 @@ module Sequel
           if (type == :update || type == :delete) && !instance_filters.empty?
             false
           else
-            super
+            super if defined?(super)
           end
         end
       end