sequel 5.39.0 → 5.72.0

data/lib/sequel/database/misc.rb

@@ -91,11 +91,23 @@ module Sequel
     # The specific default size of string columns for this Sequel::Database, usually 255 by default.
     attr_accessor :default_string_column_size
 
+    # Whether to check the bytesize of strings before typecasting (to avoid typecasting strings that
+    # would be too long for the given type), true by default. Strings that are too long will raise
+    # a typecasting error.
+    attr_accessor :check_string_typecast_bytesize
+
     # Constructs a new instance of a database connection with the specified
     # options hash.
     #
     # Accepts the following options:
+    # :after_connect :: A callable object called after each new connection is made, with the
+    #                   connection object (and server argument if the callable accepts 2 arguments),
+    #                   useful for customizations that you want to apply to all connections.
+    # :before_preconnect :: Callable that runs after extensions from :preconnect_extensions are loaded,
+    #                       but before any connections are created.
     # :cache_schema :: Whether schema should be cached for this Database instance
+    # :check_string_typecast_bytesize :: Whether to check the bytesize of strings before typecasting.
+    # :connect_sqls :: An array of sql strings to execute on each new connection, after :after_connect runs.
     # :default_string_column_size :: The default size of string columns, 255 by default.
     # :extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
     #                or string with extensions separated by columns.  These extensions are loaded after
@@ -105,7 +117,7 @@ module Sequel
     # :loggers :: An array of loggers to use.
     # :log_connection_info :: Whether connection information should be logged when logging queries.
     # :log_warn_duration :: The number of elapsed seconds after which queries should be logged at warn level.
-    # :name :: A name to use for the Database object, displayed in PoolTimeout .
+    # :name :: A name to use for the Database object, displayed in PoolTimeout.
     # :preconnect :: Automatically create the maximum number of connections, so that they don't
     #                need to be created as needed.  This is useful when connecting takes a long time
     #                and you want to avoid possible latency during runtime.
@@ -114,13 +126,15 @@ module Sequel
     # :preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
     #                           connections are made by the :preconnect option.
     # :quote_identifiers :: Whether to quote identifiers.
-    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol .
+    # :servers :: A hash specifying a server/shard specific options, keyed by shard symbol.
     # :single_threaded :: Whether to use a single-threaded connection pool.
     # :sql_log_level :: Method to use to log SQL to a logger, :info by default.
     #
+    # For sharded connection pools, :after_connect and :connect_sqls can be specified per-shard.
+    #
     # All options given are also passed to the connection pool.  Additional options respected by
-    # the connection pool are :after_connect, :connect_sqls, :max_connections, :pool_timeout,
-    # :servers, and :servers_hash.  See the connection pool documentation for details.
+    # the connection pool are :max_connections, :pool_timeout, :servers, and :servers_hash.  See the
+    # connection pool documentation for details.
     def initialize(opts = OPTS)
       @opts ||= opts
       @opts = connection_pool_default_options.merge(@opts)
@@ -130,6 +144,7 @@ module Sequel
       @opts[:adapter_class] = self.class
       @opts[:single_threaded] = @single_threaded = typecast_value_boolean(@opts.fetch(:single_threaded, Sequel.single_threaded))
       @default_string_column_size = @opts[:default_string_column_size] || DEFAULT_STRING_COLUMN_SIZE
+      @check_string_typecast_bytesize = typecast_value_boolean(@opts.fetch(:check_string_typecast_bytesize, true))
 
       @schemas = {}
       @prepared_statements = {}
@@ -160,6 +175,10 @@ module Sequel
 
         initialize_load_extensions(:preconnect_extensions)
 
+        if before_preconnect = @opts[:before_preconnect]
+          before_preconnect.call(self)
+        end
+
         if typecast_value_boolean(@opts[:preconnect]) && @pool.respond_to?(:preconnect, true)
           concurrent = typecast_value_string(@opts[:preconnect]) == "concurrently"
           @pool.send(:preconnect, concurrent)
@@ -213,8 +232,7 @@ module Sequel
       Sequel.extension(*exts)
       exts.each do |ext|
         if pr = Sequel.synchronize{EXTENSIONS[ext]}
-          unless Sequel.synchronize{@loaded_extensions.include?(ext)}
-            Sequel.synchronize{@loaded_extensions << ext}
+          if Sequel.synchronize{@loaded_extensions.include?(ext) ? false : (@loaded_extensions << ext)}
             pr.call(self)
           end
         else
@@ -460,6 +478,21 @@ module Sequel
     #   Don't rescue other exceptions, they will be raised normally.
     end
 
+    # Check the bytesize of a string before conversion. There is no point
+    # trying to typecast strings that would be way too long.
+    def typecast_check_string_length(string, max_size)
+      if @check_string_typecast_bytesize && string.bytesize > max_size
+        raise InvalidValue, "string too long to typecast (bytesize: #{string.bytesize}, max: #{max_size})"
+      end
+      string
+    end
+
+    # Check the bytesize of the string value, if value is a string.
+    def typecast_check_length(value, max_size)
+      typecast_check_string_length(value, max_size) if String === value
+      value
+    end
+
     # Typecast the value to an SQL::Blob
     def typecast_value_blob(value)
       value.is_a?(Sequel::SQL::Blob) ? value : Sequel::SQL::Blob.new(value)
@@ -483,9 +516,9 @@ module Sequel
       when Date
         value
       when String
-        Sequel.string_to_date(value)
+        Sequel.string_to_date(typecast_check_string_length(value, 100))
       when Hash
-        Date.new(*[:year, :month, :day].map{|x| (value[x] || value[x.to_s]).to_i})
+        Date.new(*[:year, :month, :day].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise InvalidValue, "invalid value for Date: #{value.inspect}"
       end
@@ -493,7 +526,17 @@ module Sequel
 
     # Typecast the value to a DateTime or Time depending on Sequel.datetime_class
     def typecast_value_datetime(value)
-      Sequel.typecast_to_application_timestamp(value)
+      case value
+      when String
+        Sequel.typecast_to_application_timestamp(typecast_check_string_length(value, 100))
+      when Hash
+        [:year, :month, :day, :hour, :minute, :second, :nanos, :offset].each do |x|
+          typecast_check_length(value[x] || value[x.to_s], 100)
+        end
+        Sequel.typecast_to_application_timestamp(value)
+      else
+        Sequel.typecast_to_application_timestamp(value)
+      end
     end
     
     if RUBY_VERSION >= '2.4'
@@ -526,18 +569,30 @@ module Sequel
       when Numeric
         BigDecimal(value.to_s)
       when String
-        _typecast_value_string_to_decimal(value)
+        _typecast_value_string_to_decimal(typecast_check_string_length(value, 1000))
       else
         raise InvalidValue, "invalid value for BigDecimal: #{value.inspect}"
       end
     end
 
     # Typecast the value to a Float
-    alias typecast_value_float Float
+    def typecast_value_float(value)
+      Float(typecast_check_length(value, 1000))
+    end
 
     # Typecast the value to an Integer
     def typecast_value_integer(value)
-      (value.is_a?(String) && value =~ /\A0+(\d)/) ? Integer(value, 10) : Integer(value)
+      case value
+      when String
+        typecast_check_string_length(value, 100)
+        if value =~ /\A-?0+(\d)/
+          Integer(value, 10)
+        else
+          Integer(value)
+        end
+      else
+        Integer(value)
+      end
     end
 
     # Typecast the value to a String
@@ -560,9 +615,9 @@ module Sequel
           SQLTime.create(value.hour, value.min, value.sec, value.nsec/1000.0)
         end
       when String
-        Sequel.string_to_time(value)
+        Sequel.string_to_time(typecast_check_string_length(value, 100))
       when Hash
-        SQLTime.create(*[:hour, :minute, :second].map{|x| (value[x] || value[x.to_s]).to_i})
+        SQLTime.create(*[:hour, :minute, :second].map{|x| typecast_check_length(value[x] || value[x.to_s], 100).to_i})
       else
         raise Sequel::InvalidValue, "invalid value for Time: #{value.inspect}"
       end

data/lib/sequel/database/query.rb

@@ -175,6 +175,15 @@ module Sequel
         if !c[:max_length] && c[:type] == :string && (max_length = column_schema_max_length(c[:db_type]))
           c[:max_length] = max_length
         end
+        if !c[:max_value] && !c[:min_value]
+          min_max = case c[:type]
+          when :integer
+            column_schema_integer_min_max_values(c)
+          when :decimal
+            column_schema_decimal_min_max_values(c)
+          end
+          c[:min_value], c[:max_value] = min_max if min_max
+        end
       end
       schema_post_process(cols)
 
@@ -236,7 +245,7 @@ module Sequel
       when :date
         Sequel.string_to_date(default)
       when :datetime
-        DateTime.parse(default)
+        Sequel.string_to_datetime(default)
       when :time
         Sequel.string_to_time(default)
       when :decimal
@@ -272,6 +281,68 @@ module Sequel
       column_schema_default_to_ruby_value(default, type) rescue nil
     end
 
+    INTEGER1_MIN_MAX = [-128, 127].freeze
+    INTEGER2_MIN_MAX = [-32768, 32767].freeze
+    INTEGER3_MIN_MAX = [-8388608, 8388607].freeze
+    INTEGER4_MIN_MAX = [-2147483648, 2147483647].freeze
+    INTEGER8_MIN_MAX = [-9223372036854775808, 9223372036854775807].freeze
+    UNSIGNED_INTEGER1_MIN_MAX = [0, 255].freeze
+    UNSIGNED_INTEGER2_MIN_MAX = [0, 65535].freeze
+    UNSIGNED_INTEGER3_MIN_MAX = [0, 16777215].freeze
+    UNSIGNED_INTEGER4_MIN_MAX = [0, 4294967295].freeze
+    UNSIGNED_INTEGER8_MIN_MAX = [0, 18446744073709551615].freeze
+
+    # Look at the db_type and guess the minimum and maximum integer values for
+    # the column.
+    def column_schema_integer_min_max_values(column)
+      db_type = column[:db_type]
+      if /decimal|numeric|number/i =~ db_type
+        if min_max = column_schema_decimal_min_max_values(column)
+          min_max.map!(&:to_i)
+        end
+        return min_max
+      end
+
+      unsigned = /unsigned/i =~ db_type
+      case db_type
+      when /big|int8/i
+        unsigned ? UNSIGNED_INTEGER8_MIN_MAX : INTEGER8_MIN_MAX
+      when /medium/i
+        unsigned ? UNSIGNED_INTEGER3_MIN_MAX : INTEGER3_MIN_MAX
+      when /small|int2/i
+        unsigned ? UNSIGNED_INTEGER2_MIN_MAX : INTEGER2_MIN_MAX
+      when /tiny/i
+        (unsigned || column_schema_tinyint_type_is_unsigned?) ? UNSIGNED_INTEGER1_MIN_MAX : INTEGER1_MIN_MAX
+      else
+        unsigned ? UNSIGNED_INTEGER4_MIN_MAX : INTEGER4_MIN_MAX
+      end
+    end
+
+    # Look at the db_type and guess the minimum and maximum decimal values for
+    # the column.
+    def column_schema_decimal_min_max_values(column)
+      if column[:column_size] && column[:scale]
+        precision = column[:column_size]
+        scale = column[:scale]
+      elsif /\((\d+)(?:,\s*(-?\d+))?\)/ =~ column[:db_type]
+        precision = $1.to_i
+        scale = $2.to_i if $2
+      end
+
+      if precision
+        limit = BigDecimal("9" * precision)
+        if scale
+          limit /= 10**(scale)
+        end
+        [-limit, limit]
+      end
+    end
+
+    # Whether the tinyint type (if supported by the database) is unsigned by default.
+    def column_schema_tinyint_type_is_unsigned?
+      false
+    end
+
     # Look at the db_type and guess the maximum length of the column.
     # This assumes types such as varchar(255).
     def column_schema_max_length(db_type)
@@ -333,7 +404,7 @@ module Sequel
         :boolean
       when /\A(real|float( unsigned)?|double( precision)?|double\(\d+,\d+\)( unsigned)?)\z/io
         :float
-      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(\d+|false|true)\))?))\z/io
+      when /\A(?:(?:(?:num(?:ber|eric)?|decimal)(?:\(\d+,\s*(-?\d+|false|true)\))?))\z/io
         $1 && ['0', 'false'].include?($1) ? :integer : :decimal
       when /bytea|blob|image|(var)?binary/io
         :blob

data/lib/sequel/database/schema_generator.rb

@@ -146,6 +146,9 @@ module Sequel
       #
       # :generated_type :: Set the type of column when using :generated_always_as,
       #                    should be :virtual or :stored to force a type.
+      # :on_update_current_timestamp :: Use ON UPDATE CURRENT TIMESTAMP when defining the column,
+      #                                 which will update the column value to CURRENT_TIMESTAMP
+      #                                 on every UPDATE.
       #
       # Microsoft SQL Server specific options:
       #
@@ -159,7 +162,7 @@ module Sequel
         nil
       end
       
-      # Adds a named constraint (or unnamed if name is nil),
+      # Adds a named CHECK constraint (or unnamed if name is nil),
       # with the given block or args. To provide options for the constraint, pass
       # a hash as the first argument.
       #
@@ -167,6 +170,15 @@ module Sequel
       #   # CONSTRAINT blah CHECK num >= 1 AND num <= 5
       #   constraint({name: :blah, deferrable: true}, num: 1..5)
       #   # CONSTRAINT blah CHECK num >= 1 AND num <= 5 DEFERRABLE INITIALLY DEFERRED
+      #
+      # If the first argument is a hash, the following options are supported:
+      #
+      # Options:
+      # :name :: The name of the CHECK constraint
+      # :deferrable :: Whether the CHECK constraint should be marked DEFERRABLE.
+      #
+      # PostgreSQL specific options:
+      # :not_valid :: Whether the CHECK constraint should be marked NOT VALID.
       def constraint(name, *args, &block)
         opts = name.is_a?(Hash) ? name : {:name=>name}
         constraints << opts.merge(:type=>:check, :check=>block || args)
@@ -205,14 +217,12 @@ module Sequel
       end
 
       # Add a full text index on the given columns.
+      # See #index for additional options.
       #
       # PostgreSQL specific options:
       # :index_type :: Can be set to :gist to use a GIST index instead of the
       #                default GIN index.
       # :language :: Set a language to use for the index (default: simple).
-      #
-      # Microsoft SQL Server specific options:
-      # :key_index :: The KEY INDEX to use for the full text index.
       def full_text_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :full_text))
       end
@@ -222,35 +232,44 @@ module Sequel
         columns.any?{|c| c[:name] == name}
       end
       
-      # Add an index on the given column(s) with the given options.
+      # Add an index on the given column(s) with the given options. Examples:
+      #
+      #   index :name
+      #   # CREATE INDEX table_name_index ON table (name)
+      #
+      #   index [:artist_id, :name]
+      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      #
+      #   index [:artist_id, :name], name: :foo
+      #   # CREATE INDEX foo ON table (artist_id, name)
+      #
       # General options:
       #
+      # :include :: Include additional column values in the index, without
+      #             actually indexing on those values (only supported by
+      #             some databases).
       # :name :: The name to use for the index. If not given, a default name
       #          based on the table and columns is used.
-      # :type :: The type of index to use (only supported by some databases)
+      # :type :: The type of index to use (only supported by some databases,
+      #          :full_text and :spatial values are handled specially).
       # :unique :: Make the index unique, so duplicate values are not allowed.
-      # :where :: Create a partial index (only supported by some databases)
+      # :where :: A filter expression, used to create a partial index (only
+      #           supported by some databases).
       #
       # PostgreSQL specific options:
       #
       # :concurrently :: Create the index concurrently, so it doesn't block
       #                  operations on the table while the index is being
       #                  built.
-      # :opclass :: Use a specific operator class in the index.
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values (PostgreSQL 11+).
+      # :if_not_exists :: Only create the index if an index of the same name doesn't already exist.
+      # :nulls_distinct :: Set whether separate NULLs should be considered distinct values in unique indexes.
+      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
+      #             custom SQL).
       # :tablespace :: Specify tablespace for index.
       #
       # Microsoft SQL Server specific options:
       #
-      # :include :: Include additional column values in the index, without
-      #             actually indexing on those values.
-      #
-      #   index :name
-      #   # CREATE INDEX table_name_index ON table (name)
-      #
-      #   index [:artist_id, :name]
-      #   # CREATE INDEX table_artist_id_name_index ON table (artist_id, name)
+      # :key_index :: Sets the KEY INDEX to the given value.
       def index(columns, opts = OPTS)
         indexes << {:columns => Array(columns)}.merge!(opts)
         nil
@@ -288,7 +307,7 @@ module Sequel
       # Examples:
       #   primary_key(:id)
       #   primary_key(:id, type: :Bignum, keep_order: true)
-      #   primary_key([:street_number, :house_number], name: :some constraint_name)
+      #   primary_key([:street_number, :house_number], name: :some_constraint_name)
       def primary_key(name, *args)
         return composite_primary_key(name, *args) if name.is_a?(Array)
         column = @db.serial_primary_key_options.merge({:name => name})
@@ -316,6 +335,7 @@ module Sequel
       end
       
       # Add a spatial index on the given columns.
+      # See #index for additional options.
       def spatial_index(columns, opts = OPTS)
         index(columns, opts.merge(:type => :spatial))
       end
@@ -371,8 +391,7 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       #
@@ -385,7 +404,10 @@ module Sequel
       # :after :: The name of an existing column that the new column should be positioned after
       # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
-        @operations << {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        op = {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        index_opts = op.delete(:index)
+        @operations << op
+        add_index(name, index_opts.is_a?(Hash) ? index_opts : OPTS) if index_opts
         nil
       end
       
@@ -414,8 +436,7 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add
@@ -442,7 +463,7 @@ module Sequel
       end
       
       # Add a full text index on the given columns.
-      # See CreateTableGenerator#index for available options.
+      # See CreateTableGenerator#full_text_index for available options.
       def add_full_text_index(columns, opts = OPTS)
         add_index(columns, {:type=>:full_text}.merge!(opts))
       end
@@ -451,34 +472,6 @@ module Sequel
       # CreateTableGenerator#index for available options.
       #
       #   add_index(:artist_id) # CREATE INDEX table_artist_id_index ON table (artist_id)
-      #
-      # Options:
-      #
-      # :name :: Give a specific name for the index. Highly recommended if you plan on
-      #          dropping the index later.
-      # :where :: A filter expression, used to setup a partial index (if supported).
-      # :unique :: Create a unique index.
-      #
-      # PostgreSQL specific options:
-      #
-      # :concurrently :: Create the index concurrently, so it doesn't require an exclusive lock
-      #                  on the table.
-      # :index_type :: The underlying index type to use for a full_text index, gin by default).
-      # :language :: The language to use for a full text index (simple by default).
-      # :opclass :: Set an opclass to use for all columns (per-column opclasses require
-      #             custom SQL).
-      # :type :: Set the index type (e.g. full_text, spatial, hash, gin, gist, btree).
-      # :if_not_exists :: Only create the index if an index of the same name doesn't already exists
-      #
-      # MySQL specific options:
-      #
-      # :type :: Set the index type, with full_text and spatial indexes handled specially.
-      #
-      # Microsoft SQL Server specific options:
-      #
-      # :include :: Includes additional columns in the index.
-      # :key_index :: Sets the KEY INDEX to the given value.
-      # :type :: clustered uses a clustered index, full_text uses a full text index.
       def add_index(columns, opts = OPTS)
         @operations << {:op => :add_index, :columns => Array(columns)}.merge!(opts)
         nil

data/lib/sequel/database/schema_methods.rb

@@ -63,7 +63,7 @@ module Sequel
     # definitions using <tt>create_table</tt>, and +add_index+ accepts all the options
     # available for index definition.
     #
-    # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc].
+    # See <tt>Schema::AlterTableGenerator</tt> and the {Migrations guide}[rdoc-ref:doc/migration.rdoc].
     def alter_table(name, &block)
       generator = alter_table_generator(&block)
       remove_cached_schema(name)
@@ -183,6 +183,15 @@ module Sequel
     #             keys.
     # :tablespace :: The tablespace to use for the table.
     #
+    # SQLite specific options:
+    # :strict :: Create a STRICT table, which checks that the values for the columns
+    #            are the correct type (similar to all other SQL databases). Note that
+    #            when using this option, all column types used should be one of the
+    #            following: +int+, +integer+, +real+, +text+, +blob+, and +any+.
+    #            The +any+ type is treated like a SQLite column in a non-strict table,
+    #            allowing any type of data to be stored. This option is supported on
+    #            SQLite 3.37.0+.
+    #
     # 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)
@@ -262,6 +271,10 @@ module Sequel
     #   # SELECT * FROM items WHERE foo
     #   # WITH CHECK OPTION
     #
+    #   DB.create_view(:bar_items, DB[:items].select(:foo), columns: [:bar])
+    #   # CREATE VIEW bar_items (bar) AS
+    #   # SELECT foo FROM items
+    #
     # Options:
     # :columns :: The column names to use for the view.  If not given,
     #             automatically determined based on the input dataset.
@@ -282,6 +295,9 @@ module Sequel
     #               in a subquery, if you are providing a Dataset as the source
     #               argument, if should probably call the union method with the
     #               all: true and from_self: false options.
+    # :security_invoker :: Set the security_invoker property on the view, making
+    #                      the access to the view use the current user's permissions,
+    #                      instead of the view owner's permissions.
     # :tablespace :: The tablespace to use for materialized views.
     def create_view(name, source, options = OPTS)
       execute_ddl(create_view_sql(name, source, options))
@@ -884,7 +900,7 @@ module Sequel
     #
     # Any other object given is just converted to a string, with "_" converted to " " and upcased.
     def on_delete_clause(action)
-      action.to_s.gsub("_", " ").upcase
+      action.to_s.tr("_", " ").upcase
     end
 
     # Alias of #on_delete_clause, since the two usually behave the same.