sequel-sequence 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a027c577de1ee27127880328c29208456a26635c9ea18b1c5eb3c1cb0dbbd5fc
-  data.tar.gz: 71764d6ec16bf3425ba3d3bfb4ac47c04dd2a6f7001342c0ae35ebec63af293d
+  metadata.gz: e6e1a94456ed2dca944d9f5dc7775acdde3db19912cf65c556fc315902dd6514
+  data.tar.gz: 0c6c8ec72019f94c819922dc3c8cc63e63e0d0138a3f95ed442384838d02beb5
 SHA512:
-  metadata.gz: 5ce8091d3c644545cecff05c0f85a6252bdd8de015710770a861bfea81793fc50c5b96d19ce304fc2158cd40fc8bfde72f88309e0dc6dea468e2a977a533f980
-  data.tar.gz: a80404a67e51b77a1dd6ac40fe8ebbd93329b170e25855024f325e965f76ec9ad723ea2698fc4f699edad9cd7eb8555c5f6b28d870eb6c2f0355c44686904b19
+  metadata.gz: 97954c433db834abdd23e91fd97abfee863f7f55bcf08d83048a6f3afd7d8fa9e780bfab010758af8b0ec01936ff1f40461ff5ec942e39bf59da894b23670798
+  data.tar.gz: 208dc0051f42068cae2009bb2ee04b0cfc1f0381aa872504621541d3ea36d8aef7aa8800559425a5c107eac8620d82f52722444d8bda0de58caf20e9ced1145f

data/CHANGELOG.md

@@ -11,6 +11,16 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v0.5.0 - 2023-10-08
+
+- [Fixed] The conditions of migrations were clarified and fixed in README.md.
+- [Added] The `delete_to_currval(name)` method for MySQL and SQLite `SEQUENCE`-table and Exceptions for any other cases.
+- [Added] The `drop_sequence?` can accept multiple arguments with condition 'IF EXISTS'.
+- [Added] The `create_sequence!` drops the `SEQUENCE` if it exists before attempting to create it.
+- [Changed] INT type to BIGINT type for the primery key of a MySQL `SEQUENCE`-table.
+- [Added] The ext. params for the PostgreSql `SEQUENCE` ( https://www.postgresql.org/docs/current/sql-createsequence.html )
+- [Added] The ext. params for the Mariadb `SEQUENCE` ( https://mariadb.com/kb/en/create-sequence )
+
 ## v0.4.2 - 2023-10-03
 
 - [Added] Additions into README.md.

data/README.md

@@ -24,8 +24,6 @@ gem 'sequel-sequence'
 To create and delete a `SEQUENCE`, simply use the `create_sequence` and `drop_sequence` methods.
 
 ```ruby
-require: 'sequel-sequence'
-
 Sequel.migration do
   up do
     create_sequence :position, if_exists: false
@@ -39,8 +37,6 @@ end
 
 It would also be correct to write:
 ```ruby
-require: 'sequel-sequence'
-
 Sequel.migration do
   up do
     create_sequence :position
@@ -86,6 +82,17 @@ Sequel.migration do
 end
 ```
 
+Before running the migration for your application, don't forget to invoke `require`s, for example like this:
+```ruby
+require 'sequel'
+require 'sequel-sequence'
+
+migrate = -> (env, version) do
+  ...
+  Sequel::Migrator.apply(DB, 'db/migrations', version)
+end
+```
+
 This gem also adds a few helpers to interact with `SEQUENCE`s.
 
 ```ruby
@@ -120,7 +127,10 @@ and
 DB.nextval_with_label(:position, 1)
 ```
 
-By default, `fiction` has a zero value.
+By default, `fiction` has a zero value. Moreover, it is assumed that you can use the history of sequence changes, for example, to collect statistics on the fiction field. However, in most cases, such statistics will not be necessary and you can program periodic cleaning of the SEQUENCE table using the method:
+```ruby
+DB.delete_to_currval(:position)
+```
 
 Otherwise, the operation of this gem for SQLite and MySQL is similar to the ways of using Sequence in more advanced RDBMS. There is only one difference here, you won't be able to change the increment value from 1 to another using the `increment` or `step` parameter.
 
@@ -129,12 +139,28 @@ Otherwise, the operation of this gem for SQLite and MySQL is similar to the ways
 - This solution does not allow you to simultaneously work with MySQL and MariaDB databases from one application. If such a need arises, move the data processing functionality to different microservices.
 - When you start with a new database in SQLite, you'll receive an error message - "`SQLite3::SQLException: no such table: sqlite_sequence`".  `sqlite_sequence` table is not created, until you define at least one autoincrement and primary key column in your schema.
 
-## Additional handy functions
+All methods defined in this gem can use either a String or a Symbol parameter to denote a `SEQUENCE`. 
+```ruby
+DB.nextval('position')
+```
+is equivalent to
+```ruby
+DB.nextval(:position)
+```
+- This solution allows you to specify advanced options for a `SEQUENCE` when creating it in PostgreSQL and MariaDB. For more information, check out the description at https://www.postgresql.org/docs/current/sql-createsequence.html and https://mariadb.com/kb/en/create-sequence.
+
+## Additional handy methods:
 
 To discover a database information about `SEQUENCE`s you could take advantage of `check_sequences` and `custom_sequence?` methods.
 - `custom_sequence?(:sequence_name)` allows you to instantly find out the availability of the called `SEQUENCE`. 
 - `check_sequences` provides complete information about known `SEQUENCE`s in the datebase. The output data depends on RDBMS.
 
+To remove several sequences at once, you can use the method:
+- `drop_sequence?` can accept multiple arguments of `SEQUENCE`s and checks the `IF EXISTS` condition for each one.
+
+To drop previous `SEQUENCE` and recreate the new one utilize the method:
+- `create_sequence!`.
+
 ## Maintainer
 
 - [Nikolai Bocharov](https://github.com/oreol-group)

data/lib/sequel/sequence/database/postgresql.rb

@@ -7,8 +7,6 @@ module Sequel
   module Sequence
     module Database
       module PostgreSQL
-        SEQUENCE_COMMENT = 'created by sequel-sequence'
-
         def quote_column_name(name)
           PG::Connection.quote_ident(name).freeze
         end
@@ -27,7 +25,7 @@ module Sequel
             return false
           end
 
-          out == SEQUENCE_COMMENT
+          out == Sequel::Database::SEQUENCE_COMMENT
         end
 
         def check_sequences
@@ -35,23 +33,37 @@ module Sequel
         end
 
         def create_sequence(name, options = {})
+          data_type = options[:data_type]
+          minvalue = options[:minvalue]
+          maxvalue = options[:maxvalue]
+          start = options[:start]
+          cache = options[:cache]
+          cycle = options[:cycle]
+          owned_by = options[:owned_by]
+
           increment = options[:increment] || options[:step]
           if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
 
           sql = ["CREATE SEQUENCE #{if_exists} #{name}"]
+          sql << "AS #{data_type}" if data_type
           sql << "INCREMENT BY #{increment}" if increment
-          sql << "START WITH #{options[:start]}" if options[:start]
+          sql << "MINVALUE  #{minvalue}" if minvalue
+          sql << "MAXVALUE  #{maxvalue}" if maxvalue
+          sql << "START WITH #{start}" if start
+          sql << "CACHE  #{cache}" if cache
+          sql << cycle.to_s if cycle
+          sql << "OWNED BY  #{owned_by}" if owned_by
           sql << ';'
-          sql << "COMMENT ON SEQUENCE #{name} IS '#{SEQUENCE_COMMENT}';"
+          sql << "COMMENT ON SEQUENCE #{name} IS '#{Sequel::Database::SEQUENCE_COMMENT}';"
 
           run(sql.join("\n"))
         end
 
-        def drop_sequence(name)
+        def drop_sequence(name, options = {})
+          if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
-          sql = "DROP SEQUENCE IF EXISTS #{name}"
-          run(sql)
+          run drop_sequence_table(name, if_exists)
         end
 
         def nextval(name)
@@ -102,6 +114,12 @@ module Sequel
           ).strip
           run sql
         end
+
+        private
+
+        def drop_sequence_table(name, if_exists = nil)
+          "DROP SEQUENCE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
+        end
       end
     end
   end

data/lib/sequel/sequence/database/server/mariadb.rb

@@ -26,22 +26,33 @@ module Sequel
           end
 
           def create_sequence(name, options = {})
+            minvalue = options[:minvalue]
+            maxvalue = options[:maxvalue]
+            start = options[:start]
+            cache = options[:cache]
+            cycle = options[:cycle]
+
             increment = options[:increment] || options[:step]
             if_exists = build_exists_condition(options[:if_exists])
             name = quote_name(name.to_s)
 
             sql = ["CREATE SEQUENCE #{if_exists || Sequel::Database::IF_NOT_EXISTS} #{name}"]
             sql << "INCREMENT BY #{increment}" if increment
-            sql << "START WITH #{options[:start]}" if options[:start]
+            sql << "MINVALUE  #{minvalue}" if minvalue
+            sql << "MAXVALUE  #{maxvalue}" if maxvalue
+            sql << "START WITH #{start}" if start
+            sql << "CACHE  #{cache}" if cache
+            sql << cycle.to_s if cycle
+            sql << "COMMENT '#{Sequel::Database::SEQUENCE_COMMENT}'"
             sql << ';'
 
             run(sql.join("\n"))
           end
 
-          def drop_sequence(name)
+          def drop_sequence(name, options = {})
+            if_exists = build_exists_condition(options[:if_exists])
             name = quote_name(name.to_s)
-            sql = "DROP SEQUENCE IF EXISTS #{name}"
-            run(sql)
+            run drop_sequence_table(name, if_exists)
           end
 
           def nextval(name)
@@ -97,6 +108,10 @@ module Sequel
           def name_of_current_database
             fetch('SELECT DATABASE() AS db;').first[:db]
           end
+
+          def drop_sequence_table(name, if_exists = nil)
+            "DROP SEQUENCE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
+          end
         end
       end
     end

data/lib/sequel/sequence/database/server/mysql.rb

@@ -75,12 +75,16 @@ module Sequel
           end
 
           def set_column_default_nextval(table, column, sequence)
-            run create_sequenced_column(stringify(table),
-                                        stringify(column),
-                                        stringify(sequence))
-            run update_sequenced_column(stringify(table),
-                                        stringify(column),
-                                        stringify(sequence))
+            run trigger_create_sequenced_column(stringify(table),
+                                                stringify(column),
+                                                stringify(sequence))
+            run trigger_update_sequenced_column(stringify(table),
+                                                stringify(column),
+                                                stringify(sequence))
+          end
+
+          def delete_to_currval(name)
+            run delete_to_current_seq(stringify(name))
           end
 
           private
@@ -97,8 +101,8 @@ module Sequel
           def create_sequence_table(name, if_exists = nil)
             %(
               CREATE TABLE #{if_exists || Sequel::Database::IF_NOT_EXISTS} #{name}
-              (id INT NOT NULL AUTO_INCREMENT PRIMARY KEY,
-               fiction INT);
+              (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+               fiction BIGINT);
             ).strip
           end
 
@@ -109,7 +113,7 @@ module Sequel
           def create_mysql_sequence
             %(
               CREATE TABLE #{Sequel::Database::IF_NOT_EXISTS} mysql_sequence
-              (name VARCHAR(40), seq INT);
+              (name VARCHAR(40), seq BIGINT);
             ).strip
           end
 
@@ -147,7 +151,7 @@ module Sequel
             "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', LAST_INSERT_ID());"
           end
 
-          def create_sequenced_column(table, _column, sequence)
+          def trigger_create_sequenced_column(table, _column, sequence)
             %(
               CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} BEFORE INSERT
               ON #{table}
@@ -160,7 +164,7 @@ module Sequel
             ).strip
           end
 
-          def update_sequenced_column(table, column, sequence)
+          def trigger_update_sequenced_column(table, column, sequence)
             %(
               CREATE TRIGGER IF NOT EXISTS #{table}_#{column} BEFORE INSERT
               ON #{table}
@@ -178,6 +182,10 @@ module Sequel
             raise e
             # :nocov:
           end
+
+          def delete_to_current_seq(name)
+            "DELETE QUICK IGNORE FROM #{name} WHERE id < (SELECT * FROM (SELECT MAX(id) FROM #{name} ) AS a);"
+          end
         end
       end
     end

data/lib/sequel/sequence/database/sqlite.rb

@@ -62,9 +62,13 @@ module Sequel
         end
 
         def set_column_default_nextval(table, column, sequence)
-          run(create_sequenced_column(stringify(table),
-                                      stringify(column),
-                                      stringify(sequence)))
+          run(trigger_create_sequenced_column(stringify(table),
+                                              stringify(column),
+                                              stringify(sequence)))
+        end
+
+        def delete_to_currval(name)
+          run delete_to_current_seq(stringify(name))
         end
 
         private
@@ -113,7 +117,7 @@ module Sequel
           "SELECT MAX(seq) AS id FROM sqlite_sequence WHERE name = '#{name}';"
         end
 
-        def create_sequenced_column(table, column, sequence)
+        def trigger_create_sequenced_column(table, column, sequence)
           %(
             CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} AFTER INSERT
             ON #{table}
@@ -125,6 +129,10 @@ module Sequel
             END;
           )
         end
+
+        def delete_to_current_seq(name)
+          "DELETE FROM #{name} WHERE id < (SELECT MAX(id) FROM #{name});"
+        end
       end
     end
   end

data/lib/sequel/sequence/database.rb

@@ -7,6 +7,7 @@ module Sequel
       DANGER_OPT_INCREMENT = 'Warning! Increments greater than 1 are not supported.'
       IF_EXISTS = 'IF EXISTS'
       IF_NOT_EXISTS = 'IF NOT EXISTS'
+      SEQUENCE_COMMENT = 'created by sequel-sequence'
 
       def check_options(params)
         log_info DANGER_OPT_INCREMENT if params[:increment] && params[:increment] != 1
@@ -73,6 +74,22 @@ module Sequel
           IF_NOT_EXISTS
         end
       end
+
+      def delete_to_currval(_name)
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
+      end
+
+      def drop_sequence?(*names)
+        names.each do |n|
+          drop_sequence(n, if_exists: true)
+        end
+        false
+      end
+
+      def create_sequence!(name, options = nil)
+        drop_sequence(name, if_exists: true)
+        create_sequence(name, options)
+      end
     end
   end
 end

data/lib/sequel/sequence/version.rb

@@ -2,6 +2,6 @@
 
 module Sequel
   module Sequence
-    VERSION = '0.4.2'
+    VERSION = '0.5.0'
   end
 end

data/test/mariadb_test_helper.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'test_helper'
+# require 'logger'
 
 MariaDB = Sequel.connect(
+  # loggers: [Logger.new($stdout)],
   adapter: 'mysql2',
   user: ENV['TEST_MARIA_USERNAME'] || 'root',
   password: ENV['TEST_MARIA_PASSWORD'] || 'root',

data/test/mysql_test_helper.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'test_helper'
+# require 'logger'
 
 MysqlDB = Sequel.connect(
+  # loggers: [Logger.new($stdout)],
   adapter: 'mysql2',
   user: ENV['TEST_MYSQL_USERNAME'] || 'root',
   password: ENV['TEST_MYSQL_PASSWORD'] || 'rootroot',

data/test/postgresql_test_helper.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require 'test_helper'
+# require 'logger'
 
 PostgresqlDB = Sequel.connect(
+  # loggers: [Logger.new($stdout)],
   adapter: 'postgres',
   user: ENV['TEST_POSTGRES_USERNAME'] || 'postgres',
   password: ENV['TEST_POSTGRES_PASSWORD'] || 'postgres',

data/test/sequel/mariadb_sequence_test.rb

@@ -230,4 +230,100 @@ class MariadbSequenceTest < Minitest::Test
 
     assert_equal pos2 - pos1, 1
   end
+
+  test 'checks exception for delete_to_currval method' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, MariaDB.currval(:position_id)
+
+    assert_raises Sequel::MethodNotAllowed do
+      MariaDB.delete_to_currval(:position_id)
+    end
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert MariaDB.custom_sequence?(:a)
+    assert MariaDB.custom_sequence?(:b)
+    assert MariaDB.custom_sequence?(:c)
+
+    MariaDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !MariaDB.custom_sequence?(:a)
+    assert !MariaDB.custom_sequence?(:b)
+    assert !MariaDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, MariaDB.currval(:position)
+
+    10.times { MariaDB.nextval(:position) }
+    assert_equal 1100, MariaDB.currval(:position)
+
+    MariaDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, MariaDB.currval(:position)
+
+    10.times { MariaDB.nextval(:position) }
+    assert_equal 11, MariaDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, MariaDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, MariaDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { minvalue: -9_223_372_036_854_775_807 }
+      end
+    end.up
+
+    assert_equal(-9_223_372_036_854_775_807, MariaDB.currval(:position))
+    assert_equal(-9_223_372_036_854_775_806, MariaDB.nextval(:position))
+  end
+
+  # https://mariadb.com/kb/en/create-sequence/#arguments-to-create
+  test 'adds sequence with ext. params' do
+    with_migration do
+      def up
+        create_sequence :position, {
+          minvalue: -250,
+          maxvalue: 250,
+          start: -1,
+          cache: 3,
+          cycle: 'CYCLE',
+          increment: 2,
+          if_exists: false
+        }
+      end
+    end.up
+
+    assert_equal(-1, MariaDB.nextval('position'))
+    assert_equal 1, MariaDB.nextval('position')
+  end
 end

data/test/sequel/mock_sequence_test.rb

@@ -20,7 +20,7 @@ class MockSequenceTest < Minitest::Test
     mocked_method.verify
   end
 
-  test 'checks custom_sequence?' do
+  test 'checks "custom_sequence?"' do
     assert_raises Sequel::MethodNotAllowed do
       MockDB.custom_sequence?(:position)
     end
@@ -97,4 +97,22 @@ class MockSequenceTest < Minitest::Test
   test 'checks build_exists_condition for a non boolean condition' do
     assert_nil MockDB.build_exists_condition('')
   end
+
+  test 'checks delete_to_currval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.delete_to_currval(:position)
+    end
+  end
+
+  test 'checks "drop_sequence?"' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.drop_sequence?(:position)
+    end
+  end
+
+  test 'checks "create_sequence!"' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.create_sequence!(:position)
+    end
+  end
 end

data/test/sequel/mysql_sequence_test.rb

@@ -394,4 +394,95 @@ class MysqlSequenceTest < Minitest::Test
     MysqlDB.setval(:position, 100)
     assert_equal 100, MysqlDB.currval(:position)
   end
+
+  test 'deletes history from the sequence_table' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, MysqlDB.currval(:position_id)
+
+    sequence_table_size = MysqlDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+
+    10.times { MysqlDB.nextval(:position_id) }
+
+    assert_equal 11, MysqlDB.currval(:position_id)
+
+    sequence_table_size = MysqlDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 11, sequence_table_size
+
+    MysqlDB.delete_to_currval(:position_id)
+
+    assert_equal 11, MysqlDB.currval(:position_id)
+
+    sequence_table_size = MysqlDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert MysqlDB.custom_sequence?(:a)
+    assert MysqlDB.custom_sequence?(:b)
+    assert MysqlDB.custom_sequence?(:c)
+
+    MysqlDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !MysqlDB.custom_sequence?(:a)
+    assert !MysqlDB.custom_sequence?(:b)
+    assert !MysqlDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, MysqlDB.currval(:position)
+
+    10.times { MysqlDB.nextval(:position) }
+    assert_equal 1010, MysqlDB.currval(:position)
+
+    MysqlDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, MysqlDB.currval(:position)
+
+    10.times { MysqlDB.nextval(:position) }
+    assert_equal 11, MysqlDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, MysqlDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, MysqlDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table (does not support)' do
+    with_migration do
+      def up
+        create_sequence :position, { start: -9_223_372_036_854_775_807 }
+      end
+    end.up
+
+    assert_equal(-9_223_372_036_854_775_807, MysqlDB.currval(:position))
+    # https://www.cockroachlabs.com/docs/stable/serial#generated-values-for-modes-rowid-and-virtual_sequence
+    # "...negative values are not returned."
+    assert_equal 1, MysqlDB.nextval(:position)
+  end
 end

data/test/sequel/postgresql_sequence_test.rb

@@ -238,4 +238,102 @@ class PostgresqlSequenceTest < Minitest::Test
 
     assert_equal pos2 - pos1, 1
   end
+
+  test 'checks exception for delete_to_currval method' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, PostgresqlDB.currval(:position_id)
+
+    assert_raises Sequel::MethodNotAllowed do
+      PostgresqlDB.delete_to_currval(:position_id)
+    end
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert PostgresqlDB.custom_sequence?(:a)
+    assert PostgresqlDB.custom_sequence?(:b)
+    assert PostgresqlDB.custom_sequence?(:c)
+
+    PostgresqlDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !PostgresqlDB.custom_sequence?(:a)
+    assert !PostgresqlDB.custom_sequence?(:b)
+    assert !PostgresqlDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, PostgresqlDB.currval(:position)
+
+    10.times { PostgresqlDB.nextval(:position) }
+    assert_equal 1100, PostgresqlDB.currval(:position)
+
+    PostgresqlDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, PostgresqlDB.currval(:position)
+
+    10.times { PostgresqlDB.nextval(:position) }
+    assert_equal 11, PostgresqlDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, PostgresqlDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, PostgresqlDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { minvalue: -9_223_372_036_854_775_808 }
+      end
+    end.up
+
+    assert_equal(-9_223_372_036_854_775_808, PostgresqlDB.currval(:position))
+    assert_equal(-9_223_372_036_854_775_807, PostgresqlDB.nextval(:position))
+  end
+
+  # https://www.postgresql.org/docs/current/sql-createsequence.html
+  test 'adds sequence with ext. params' do
+    with_migration do
+      def up
+        create_sequence :position, {
+          data_type: 'smallint',
+          minvalue: -250,
+          maxvalue: 250,
+          start: -1,
+          cache: 3,
+          cycle: 'CYCLE',
+          owned_by: 'NONE',
+          increment: 2,
+          if_exists: false
+        }
+      end
+    end.up
+
+    assert_equal(-1, PostgresqlDB.nextval('position'))
+    assert_equal 1, PostgresqlDB.nextval('position')
+  end
 end

data/test/sequel/sqlite_sequence_test.rb

@@ -366,4 +366,93 @@ class SqliteSequenceTest < Minitest::Test
     SQLiteDB.setval(:position, 100)
     assert_equal 100, SQLiteDB.currval(:position)
   end
+
+  test 'deletes history from the sequence_table' do
+    with_migration do
+      def up
+        create_sequence :position_id, if_exists: false, start: 1
+      end
+    end.up
+
+    assert_equal 1, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+
+    10.times { SQLiteDB.nextval(:position_id) }
+
+    assert_equal 11, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 11, sequence_table_size
+
+    SQLiteDB.delete_to_currval(:position_id)
+
+    assert_equal 11, SQLiteDB.currval(:position_id)
+
+    sequence_table_size = SQLiteDB.fetch('SELECT count(*) as len FROM position_id;').first[:len]
+    assert_equal 1, sequence_table_size
+  end
+
+  test 'deletes sequences by "drop_sequence?"' do
+    with_migration do
+      def up
+        create_sequence :a
+        create_sequence :b
+        create_sequence :c
+      end
+    end.up
+
+    assert SQLiteDB.custom_sequence?(:a)
+    assert SQLiteDB.custom_sequence?(:b)
+    assert SQLiteDB.custom_sequence?(:c)
+
+    SQLiteDB.drop_sequence?(:a, :b, :c, :d)
+
+    assert !SQLiteDB.custom_sequence?(:a)
+    assert !SQLiteDB.custom_sequence?(:b)
+    assert !SQLiteDB.custom_sequence?(:c)
+  end
+
+  test 'deletes if exists before creating! the sequence' do
+    with_migration do
+      def up
+        create_sequence! :position, { start: 1000, increment: 10 }
+      end
+    end.up
+
+    assert_equal 1000, SQLiteDB.currval(:position)
+
+    10.times { SQLiteDB.nextval(:position) }
+    assert_equal 1010, SQLiteDB.currval(:position)
+
+    SQLiteDB.create_sequence!(:position, { start: 1, increment: 1 })
+
+    assert_equal 1, SQLiteDB.currval(:position)
+
+    10.times { SQLiteDB.nextval(:position) }
+    assert_equal 11, SQLiteDB.currval(:position)
+  end
+
+  test 'checks the BIGINT primery key for a sequence table' do
+    with_migration do
+      def up
+        create_sequence :position, { start: 9_223_372_036_854_775_800 }
+      end
+    end.up
+
+    assert_equal 9_223_372_036_854_775_800, SQLiteDB.currval(:position)
+    assert_equal 9_223_372_036_854_775_801, SQLiteDB.nextval(:position)
+  end
+
+  test 'checks the BIGINT primery key with negative value for a sequence table (does not support)' do
+    with_migration do
+      def up
+        create_sequence :position, { start: -9_223_372_036_854_775_807 }
+      end
+    end.up
+
+    assert_equal 0, SQLiteDB.currval(:position)
+    assert_equal 1, SQLiteDB.nextval(:position)
+  end
 end

data/test/sqlite_test_helper.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'test_helper'
-require 'logger'
+# require 'logger'
 
 SQLiteDB = Sequel.connect(
-  "sqlite://#{ENV.fetch('TEST_SQLITE_DATABASE', nil) || 'db/test.sqlite3'}",
-  loggers: [Logger.new($stdout)]
+  # loggers: [Logger.new($stdout)],
+  "sqlite://#{ENV.fetch('TEST_SQLITE_DATABASE', nil) || 'db/test.sqlite3'}"
 )
 
 module SqliteTestHelper

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-sequence
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Nikolai Bocharov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-03 00:00:00.000000000 Z
+date: 2023-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel