sequel 5.60.1 → 5.62.0

data/doc/release_notes/5.62.0.txt

@@ -0,0 +1,132 @@
+= New Features
+
+* The pg_auto_parameterize extension for automatically using bound
+  variables when using postgres adapter with the pg driver has been
+  added back to Sequel.  This extension was originally added in Sequel
+  3.34.0, but was removed in 4.0.0 due to the many corner cases it
+  had.  Almost all of the corner cases have now been fixed, and
+  the extension is now recommended for production use.  Compared
+  to the original version in Sequel 3, the reintroduced version
+  of the extension includes the following changes:
+
+  * Handles integers used in LIMIT/ORDER
+  * Respects explicit CASTs
+  * Tries to convert column IN (int, ...) into column = ANY($) with an
+    array parameter
+  * Uses the same parameter for the same object used more than once in
+    a query
+  * Uses parameters when inserting multiple rows via Dataset#import
+  * Supports automatically parameterizing all of the
+    PostgreSQL-specific types that Sequel ships support for in pg_*
+    extensions (though some values of those types may not support
+    automatic parameterization).
+  * Supports skipping auto parameterization for specific values.
+
+  Automatic parameterization is generally slower than Sequel's default
+  behavior, since some optimizations Sequel uses by default do not
+  currently support automatic parameterization.
+
+  Applications may need changes to work correctly with the
+  pg_auto_parameterize extension, such as the addition of explicit
+  casts.  Please read the extension documentation for more details.
+
+* Integer column schema entries now include :min_value and :max_value
+  entries on most databases, indicating the minimum and maximum values
+  supported for the column.
+
+  The validation_helpers plugin now has validates_max_value and
+  validates_min_value for testing the column value is not greater
+  than the given maximum value and not less than the given minimum
+  value, respectively.
+
+  The auto_validations plugin now automatically uses the :min_value
+  and :max_value column schema entries with the new validation_helpers
+  methods to validate that the column values for integer columns are
+  in the allowed range.
+
+* A primary_key_lookup_check_values plugin has been added for
+  automatically typecasting and checking the primary key values are
+  in the allowed range (given by :min_value and :max_value column
+  schema entries) during lookup. If typecasting fails or the value
+  is outside the allowed range, the primary key lookup will return
+  nil without issuing a query (or will raise a NoMatchingRow error
+  if using with_pk!).
+
+  Note that this can change behavior in some cases if you are
+  passing filter conditions during lookup instead of passing primary
+  key values. The plugin tries to support most common filter
+  conditions, but there are still cases that will break.
+
+* Sequel now supports shard-specific :after_connect and :connect_sqls
+  Database options, allowing you to customize behavior for specific
+  shards:
+
+    DB = Sequel.connect('url', servers: {
+        :shard1 => {host: '...', after_connect: proc{|conn|}},
+        :shard2 => {host: '...', connect_sqls: ['...']},
+      })
+
+  Note that these shard-specific options will not be respected if you
+  are calling after_connect= or connect_sqls= on the Database's
+  connection pool.
+
+= Other Improvements
+
+* A Sequel::Postgres::IntegerOutsideBigintRange exception will now be
+  raised if trying to literalize an integer outside PostgreSQL bigint
+  range, to avoid PostgreSQL treating the integer as a numeric type
+  and not respecting indexes on the related column.
+
+  A pg_extended_integer_support extension has been added for
+  customizing the behavior when literalizing an integer outside
+  PostgreSQL bigint range, either quoting it or getting the
+  historical behavior of using it directly in the query.
+
+* Dataset#import and #multi_insert no longer use transactions when
+  they only run a single query.
+
+* Fractional seconds in timestamps are now respected in the
+  named_timezones extension.
+
+* Using hstore[] types as bound variables now works on PostgreSQL.
+
+* Using BC dates and timestamps in bound variables now works on
+  PostgreSQL.
+
+* A corner case has been fixed in eager loading where the window
+  function eager limit strategy would be used without removing the
+  row_number entries from the result.
+
+* The shared postgres adapter now caches reflection datasets, speeding
+  up Database#indexes and similar methods.
+
+* The mock postgres adapter now assumes PostgreSQL 15 instead of
+  PostgreSQL 14 by default.
+
+= Backwards Compatibility
+
+* If you are using Ruby integers outside PostgreSQL bigint range when
+  dealing with PostgreSQL numeric column values, this version may
+  not be compatible.  It is recommended you explicitly convert the
+  Ruby integers to BigDecimal objects if you are using them for
+  numeric column values.  You can also use the
+  pg_extended_integer_support extension introduced in this version.
+
+= Workaround for Older Versions
+
+* If you cannot upgrade to Sequel 5.62.0, but still want to avoid the
+  problems that come from using literal large integers on PostgreSQL,
+  you can use the following code, where DB is your Sequel::Database
+  object:
+
+    DB.extend_datasets do
+      def literal_integer(v)
+        if v > 9223372036854775807 || v < -9223372036854775808
+          raise Sequel::InvalidValue, "PostgreSQL int too large: #{v}"
+        end
+        super
+      end
+    end
+
+  This workaround should work all the way back to Sequel 3.29.0,
+  released in November 2011.

data/doc/schema_modification.rdoc

@@ -377,7 +377,7 @@ Sequel will not add a column, but will add a composite primary key constraint:
 It is possible to specify a name for the primary key constraint: via the :name option:
 
   alter_table(:albums_artists) do
-    add_primary_key [:album_id, :artist_id], :name=>:albums_artists_pkey
+    add_primary_key [:album_id, :artist_id], name: :albums_artists_pkey
   end
 
 If you just want to take an existing single column and make it a primary key, call

data/doc/security.rdoc

@@ -127,8 +127,8 @@ a ruby string as raw SQL.  For example:
   DB.literal(Date.today) # "'2013-03-22'"
   DB.literal('a') # "'a'"
   DB.literal(Sequel.lit('a')) # "a"
-  DB.literal(:a => 'a') # "(\"a\" = 'a')"
-  DB.literal(:a => Sequel.lit('a')) # "(\"a\" = a)"
+  DB.literal(a: 'a') # "(\"a\" = 'a')"
+  DB.literal(a: Sequel.lit('a')) # "(\"a\" = a)"
 
 ==== SQL Filter Fragments
 
@@ -178,7 +178,7 @@ user input for function names.
 For backwards compatibility, Sequel supports regular strings in the
 window function :frame option, which will be treated as a literal string:
 
-  DB[:table].select{fun(arg).over(:frame=>'SQL Here')}
+  DB[:table].select{fun(arg).over(frame: 'SQL Here')}
 
 You should make sure the frame argument is not derived from user input,
 or switch to using a hash as the :frame option value.
@@ -237,7 +237,7 @@ or:
 
 Instead, you should do:
 
-  DB[:table].update(:column => params[:value].to_s) # Safe
+  DB[:table].update(column: params[:value].to_s) # Safe
 
 Because using the auto_literal_strings extension makes SQL injection
 so much eaiser, it is recommended to not use it, and instead
@@ -402,29 +402,29 @@ This issue isn't necessarily specific to Sequel, but it is a good general practi
 If you are using values derived from user input, it is best to be explicit about
 their type.  For example:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 is probably a bad idea.  Assuming you are using a web framework, <tt>params[:id]</tt> could
 be a string, an array, a hash, nil, or potentially something else.
 
 Assuming that +id+ is an integer field, you probably want to do:
 
-  Album.where(:id=>params[:id].to_i)
+  Album.where(id: params[:id].to_i)
 
 If you are looking something up by name, you should try to enforce the value to be
 a string:
 
-  Album.where(:name=>params[:name].to_s)
+  Album.where(name: params[:name].to_s)
 
 If you are trying to use an IN clause with a list of id values based on input provided
 on a web form:
 
-  Album.where(:id=>params[:ids].to_a.map(&:to_i))
+  Album.where(id: params[:ids].to_a.map(&:to_i))
 
 Basically, be as explicit as possible. While there aren't any known security issues
 in Sequel when you do:
 
-  Album.where(:id=>params[:id])
+  Album.where(id: params[:id])
 
 It allows the attacker to choose to do any of the following queries:
 

data/doc/sql.rdoc

@@ -223,22 +223,22 @@ If the database supports window functions, Sequel can handle them by calling the
   DB[:albums].select{count.function.*.over}
   # SELECT count(*) OVER () FROM albums
 
-  DB[:albums].select{function(:col1).over(:partition=>col2, :order=>col3)}
+  DB[:albums].select{function(:col1).over(partition: col2, order: col3)}
   # SELECT function(col1) OVER (PARTITION BY col2 ORDER BY col3) FROM albums
 
-  DB[:albums].select{function(c1, c2).over(:partition=>[c3, c4], :order=>[c5, c6.desc])}
+  DB[:albums].select{function(c1, c2).over(partition: [c3, c4], order: [c5, c6.desc])}
   # SELECT function(c1, c2) OVER (PARTITION BY c3, c4 ORDER BY c5, c6 DESC) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>:rows)}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: :rows)}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>1, :end=>1})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: 1, end: 1})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:groups, :start=>[2, :preceding], :end=>[1, :preceding]})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :groups, start: [2, :preceding], end: [1, :preceding]})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 GROUPS BETWEEN 2 PRECEDING AND 1 PRECEDING) FROM albums
 
-  DB[:albums].select{function(c1).over(:partition=>c2, :order=>:c3, :frame=>{:type=>:range, :start=>:preceding, :exclude=>:current})}
+  DB[:albums].select{function(c1).over(partition: c2, order: :c3, frame: {type: :range, start: :preceding, exclude: :current})}
   # SELECT function(c1) OVER (PARTITION BY c2 ORDER BY c3 RANGE UNBOUNDED PRECEDING EXCLUDE CURRENT ROW) FROM albums
 
 === Schema Qualified Functions
@@ -551,8 +551,8 @@ You can also use the <tt>Sequel.asc</tt> and <tt>Sequel.desc</tt> methods:
 
 On some databases, you can specify null ordering:
 
-  Sequel.asc(:column, :nulls=>:first) # "column" ASC NULLS FIRST
-  Sequel.desc(Sequel[:table][:column], :nulls=>:last) # "table"."column" DESC NULLS LAST
+  Sequel.asc(:column, nulls: :first) # "column" ASC NULLS FIRST
+  Sequel.desc(Sequel[:table][:column], nulls: :last) # "table"."column" DESC NULLS LAST
 
 === All Columns (.*)
 
@@ -629,16 +629,16 @@ Also note that while the SELECT clause is displayed when you look at a dataset,
 
   ds = DB[:albums]
   ds.all # SELECT * FROM albums
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF'
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF'
   ds.delete # DELETE FROM albums
 
 In general, the +insert+, +update+, and +delete+ methods use the appropriate clauses you defined on the dataset:
 
-  ds = DB[:albums].where(:id=>1)
+  ds = DB[:albums].where(id: 1)
   ds.all # SELECT * FROM albums WHERE (id = 1)
-  ds.insert(:name=>'RF') # INSERT INTO albums (name) VALUES ('RF')
-  ds.update(:name=>'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
+  ds.insert(name: 'RF') # INSERT INTO albums (name) VALUES ('RF')
+  ds.update(name: 'RF') # UPDATE albums SET name = 'RF' WHERE (id = 1)
   ds.delete # DELETE FROM albums WHERE (id = 1)
 
 Note how +update+ and +delete+ used the +where+ argument, but +insert+ did not, because INSERT doesn't use a WHERE clause.

data/doc/testing.rdoc

@@ -15,7 +15,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -24,7 +24,7 @@ These run each test in its own transaction, the recommended way to test.
   
   class Minitest::Spec
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -34,7 +34,7 @@ These run each test in its own transaction, the recommended way to test.
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, auto_savepoint: true){super}
     end
   end
 
@@ -43,7 +43,7 @@ These run each test in its own transaction, the recommended way to test.
   
   RSpec.configure do |c|
     c.around(:each) do |example|
-      DB.transaction(:rollback=>:always, :auto_savepoint=>true){example.run}
+      DB.transaction(rollback: :always, auto_savepoint: true){example.run}
     end
   end
 
@@ -51,11 +51,11 @@ These run each test in its own transaction, the recommended way to test.
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
 
-  DB.transaction(:rollback=>:always)
+  DB.transaction(rollback: :always)
 
 Use Sequel.transaction with an array of databases:
 
-  Sequel.transaction([DB1, DB2, DB3], :rollback=>:always)
+  Sequel.transaction([DB1, DB2, DB3], rollback: :always)
 
 == Transactional testing with savepoints
 
@@ -71,11 +71,11 @@ Example:
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+      DB.transaction(rollback: :always, savepoint: true, auto_savepoint: true){super}
     end
 
     def around_all
-      DB.transaction(:rollback=>:always){super}
+      DB.transaction(rollback: :always){super}
     end
   end
 
@@ -161,22 +161,24 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 SEQUEL_ASYNC_THREAD_POOL :: Use the async_thread_pool extension when running the specs
 SEQUEL_ASYNC_THREAD_POOL_PREEMPT :: Use the async_thread_pool extension when running the specs, with the :preempt_async_thread option
+SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
+SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
 SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
-SEQUEL_CONCURRENT_EAGER_LOADING :: Use the async_thread_pool extension and concurrent_eager_loading plugin when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
-SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_FIBER_CONCURRENCY :: Use the fiber_concurrency extension when running the adapter and integration specs
 SEQUEL_FREEZE_DATABASE :: Freeze the database before running the integration specs
 SEQUEL_IDENTIFIER_MANGLING :: Use the identifier_mangling extension when running the specs
+SEQUEL_INDEX_CACHING :: Use the index_caching extension when running the specs
 SEQUEL_INTEGER64 :: Use the integer64 extension when running the adapter or integration specs
 SEQUEL_MODEL_PREPARED_STATEMENTS :: Use the prepared_statements plugin when running the specs
 SEQUEL_MODEL_THROW_FAILURES :: Use the throw_failures plugin when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs
-SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
+SEQUEL_PG_AUTO_PARAMETERIZE :: Use the pg_auto_parameterize extension when running the postgres specs
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
+SEQUEL_PRIMARY_KEY_LOOKUP_CHECK_VALUES :: Use the primary_key_lookup_check_values extension when running the adapter or integration specs
 SEQUEL_QUERY_PER_ASSOCIATION_DB_0_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_QUERY_PER_ASSOCIATION_DB_1_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)
 SEQUEL_QUERY_PER_ASSOCIATION_DB_2_URL :: Run query-per-association integration tests with multiple databases (all 4 must be set to run)

data/doc/transactions.rdoc

@@ -127,28 +127,28 @@ Other exceptions, unless rescued inside the outer transaction block, will rollba
   end # ROLLBACK
   # ArgumentError raised
 
-If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
+If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(savepoint: true)</tt>
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
-      DB.rollback_on_exit(:savepoint=>true)
+      DB.rollback_on_exit(savepoint: true)
     end # ROLLBACK TO SAVEPOINT
   end # COMMIT
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>true)
+        DB.rollback_on_exit(savepoint: true)
       end # ROLLBACK TO SAVEPOINT
     end # RELEASE SAVEPOINT
   end # COMMIT
 
-If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>integer)</tt>
+If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(savepoint: integer)</tt>
 
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>2)
+        DB.rollback_on_exit(savepoint: 2)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # COMMIT
@@ -156,7 +156,7 @@ If you want the current savepoint and potentially enclosing savepoints to be rol
   DB.transaction do # BEGIN
     DB.transaction(savepoint: true) do # SAVEPOINT
       DB.transaction(savepoint: true) do # SAVEPOINT
-        DB.rollback_on_exit(:savepoint=>3)
+        DB.rollback_on_exit(savepoint: 3)
       end # ROLLBACK TO SAVEPOINT
     end # ROLLBACK TO SAVEPOINT
   end # ROLLBACK

data/doc/virtual_rows.rdoc

@@ -23,7 +23,7 @@ With virtual rows, you can use the less verbose:
 Virtual row blocks behave differently depending on whether the block accepts
 an argument.  If the block accepts an argument, it is called with an instance
 of Sequel::SQL::VirtualRow.  If it does not accept an argument, it is
-evaluated in the context of an instance of Sequel::SQL::VirtualRow.
+evaluated in the <em> context of an instance </em> of Sequel::SQL::VirtualRow.
 
   ds = DB[:items]
   # Regular block

data/lib/sequel/adapters/postgres.rb

@@ -185,8 +185,12 @@ module Sequel
         case arg
         when Sequel::SQL::Blob
           {:value=>arg, :type=>17, :format=>1}
+        # :nocov:
+        # Not covered by tests as tests use pg_extended_date_support
+        # extension, which has basically the same code.
         when DateTime, Time
           literal(arg)
+        # :nocov:
         else
           arg
         end

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

@@ -17,7 +17,7 @@ module Sequel
 
       # Doesn't work, due to security restrictions on MSysObjects
       #def tables
-      #  from(:MSysObjects).where(:Type=>1, :Flags=>0).select_map(:Name).map(&:to_sym)
+      #  from(:MSysObjects).where(Type: 1, Flags: 0).select_map(:Name).map(&:to_sym)
       #end
       
       # Access doesn't support renaming tables from an SQL query,
@@ -57,6 +57,14 @@ module Sequel
         DATABASE_ERROR_REGEXPS
       end
 
+      # Access's Byte type will accept much larger values,
+      # even though it only stores 0-255.  Do not set min/max
+      # values for the Byte type.
+      def column_schema_integer_min_max_values(db_type)
+        return if /byte/i =~ db_type
+        super
+      end
+
       def drop_index_sql(table, op)
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end

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

@@ -325,6 +325,11 @@ module Sequel
         false
       end
 
+      # MSSQL tinyint types are unsigned.
+      def column_schema_tinyint_type_is_unsigned?
+        true
+      end
+
       # Handle MSSQL specific default format.
       def column_schema_normalize_default(default, type)
         if m = /\A(?:\(N?('.*')\)|\(\((-?\d+(?:\.\d+)?)\)\))\z/.match(default)
@@ -800,11 +805,10 @@ module Sequel
         if opts[:return] == :primary_key && !@opts[:output]
           output(nil, [SQL::QualifiedIdentifier.new(:inserted, first_primary_key)])._import(columns, values, opts)
         elsif @opts[:output]
-          statements = multi_insert_sql(columns, values)
-          ds = naked
-          @db.transaction(opts.merge(:server=>@opts[:server])) do
-            statements.map{|st| ds.with_sql(st)}
-          end.first.map{|v| v.length == 1 ? v.values.first : v}
+          # no transaction: our multi_insert_sql_strategy should guarantee
+          # that there's only ever a single statement.
+          sql = multi_insert_sql(columns, values)[0]
+          naked.with_sql(sql).map{|v| v.length == 1 ? v.values.first : v}
         else
           super
         end

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

@@ -550,6 +550,13 @@ module Sequel
         end
       end
 
+      # Return nil if CHECK constraints are not supported, because
+      # versions that don't support check constraints don't raise
+      # errors for values outside of range.
+      def column_schema_integer_min_max_values(db_type)
+        super if supports_check_constraints?
+      end
+
       # Split DROP INDEX ops on MySQL 5.6+, as dropping them in the same
       # statement as dropping a related foreign key causes an error.
       def split_alter_table_op?(op)

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

@@ -178,6 +178,13 @@ module Sequel
         ''
       end
 
+      # Do not support min/max integer values on Oracle, since
+      # Oracle uses a number type, and integer just adds a
+      # constaint on the number type.
+      def column_schema_integer_min_max_values(db_type)
+        nil
+      end
+
       def create_sequence_sql(name, opts=OPTS)
         "CREATE SEQUENCE #{quote_identifier(name)} start with #{opts [:start_with]||1} increment by #{opts[:increment_by]||1} nomaxvalue"
       end