sequel-sequence 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39e70601cb32fc0e4240423134984c665c0691ebb68aa2b1038b43ea0e978176
-  data.tar.gz: ad285adcee5907a0d40d3ecd7d4e2bb67d3711876c75687276a58f71304cf48a
+  metadata.gz: c7012e03aa326861bef294edcf042850f662f9122664da409aa0dd764d9375d9
+  data.tar.gz: b309b36a931be17ee7cb628c21083ef8543bb60139a249aa9fd1d42378321297
 SHA512:
-  metadata.gz: 0b97dc0b9a8b1c531d3863de2c52fde8ae2f0013aca027035fef391e2977db84520e6a00b059118a7c62ce77c57f7333abbfab56dad13d0b425d2ff4f923c02f
-  data.tar.gz: e35322803655e71d7118c3ec3e63e554ffaa73e0669e3d0947ad386d277d8b465c66b677ee9aa9bc14843062fef0331865682df769e2b2aa3fa136bca8e7029c
+  metadata.gz: 7c13a9a6e000990aaee2bdcca4d3d7519a7164c3217d4164f35e40e43deb76f652215169396647568cb03cf111d2a103f2f0f5d5f45e174b8107588e4be1808f
+  data.tar.gz: e9483ab69ea26d780164a4e4683d75c2bd86d8c5d92983b506645c5544a3ebc277f25f12a463b1f959f675f0e780eaf3b22a82b9560e247f16f2a895518d0e53

data/.github/workflows/ci.yml

@@ -56,6 +56,7 @@ jobs:
           DEBIAN_FRONTEND="noninteractive" sudo apt-get install -yqq mysql-client libmysqlclient-dev postgresql-client libpq-dev
           mysql --host 127.0.0.1 --port ${{ job.services.mysql.ports[3306] }} -uroot -proot -e "SHOW GRANTS FOR 'root'@'localhost'"
           env PGPASSWORD=postgres psql -h localhost -p ${{ job.services.postgres.ports[5432] }} -U postgres -l
+          sqlite3 --version
 
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
@@ -73,6 +74,10 @@ jobs:
         run: |
           psql -c 'create database "test";' -U postgres -h localhost -p ${{ job.services.postgres.ports[5432] }}
 
+      - name: Create SQLite database
+        run: |
+          mkdir ./db && touch ./db/test.sqlite3 && sqlite3 ./db/test.sqlite3
+
       - name: Run Tests
         run: bundle exec rake test
         env:
@@ -86,6 +91,7 @@ jobs:
           TEST_MYSQL_PORT: ${{ job.services.mysql.ports[3306] }}
           TEST_MYSQL_USERNAME: root
           TEST_MYSQL_PASSWORD: root
+          TEST_SQLITE_DATABASE: "db/test.sqlite3"
 
       - name: Run Rubocop
         run: bundle exec rake rubocop

data/.gitignore

@@ -8,7 +8,10 @@ doc
 pkg
 tmp
 log
+db
 
 ## PROJECT::SPECIFIC
 .bundle
+.byebug_history
 Gemfile.lock
+*.gem

data/CHANGELOG.md

@@ -11,6 +11,13 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v0.3.0 - 2023-09-21
+
+- [Added] A parametrized 'IF EXISTS' condition into the drop_sequence.
+- [Added] A parametrized 'IF NOT EXISTS' condition into the create_sequence.
+- [Added] Gem API support for SQLite databases.
+- [Fixed] Tests for the Mysql database.
+
 ## v0.2.0 - 2023-09-14
 
 - [Added] CI features based on GitHub Actions.

data/CONTRIBUTING.md

@@ -123,8 +123,19 @@ MariaDB [(none)]> USE test;
 MariaDB [test]> CREATE TABLE IF NOT EXISTS wares(id int auto_increment, primary key(id));
 MariaDB [test]> CREATE TABLE IF NOT EXISTS builders(id int auto_increment, primary key(id));
 ```
+- Add a test SQLite database:
+```bash
+mkdir db && touch db/test.sqlite3
+```
+- Add a couple of tables in the SQLite database:
+```bash
+sqlite3 db/test.sqlite3
+sqlite> create table objects(id integer primary key autoincrement);
+sqlite> create table apprentices(id integer primary key autoincrement);
+```
 - Run the tests separately:
 ```bash
 bundle exec rake TEST=test/sequel/postgresql_sequence_test.rb
 bundle exec rake TEST=test/sequel/mysql_sequence_test.rb
+bundle exec rake TEST=test/sequel/sqlite_sequence_test.rb
 ```

data/README.md

@@ -3,8 +3,9 @@
 [![CI](https://github.com/oreol-group/sequel-sequence/actions/workflows/ci.yml/badge.svg)](https://github.com/oreol-group/sequel-sequence)
 [![Gem](https://img.shields.io/gem/v/sequel-sequence.svg)](https://rubygems.org/gems/sequel-sequence)
 [![Downloads total](https://img.shields.io/gem/dt/sequel-sequence.svg)](https://rubygems.org/profiles/it_architect)
+[![Code Climate](https://codeclimate.com/github/Oreol-Group/sequel-sequence.svg)](https://codeclimate.com/github/Oreol-Group/sequel-sequence)
 
-Adds a useful interface and support for PostgreSQL and MySQL `SEQUENCE` on Sequel migrations
+Adds a useful interface and support for PostgreSQL and MySQL `SEQUENCE` on Sequel migrations. Gem includes functionality to cover the needs of SQLite users as well.
 
 ## Installation
 
@@ -18,14 +19,14 @@ Or add the following line to your project's Gemfile:
 gem "sequel-sequence"
 ```
 
-## Usage
+## Usage with PostgreSQL and MariaDB
 
 To create a `SEQUENCE`, just use the method `create_sequence`.
 
 ```ruby
 Sequel.migration do
   up do
-    create_sequence :position
+    create_sequence :position, if_exists: false
   end
 
   down do
@@ -39,22 +40,22 @@ You can also specify the initial value and increment:
 ```ruby
 create_sequence :position, increment: 2
 create_sequence :position, start: 100
+create_sequence :position, if_exists: false
 ```
 
-To define a column that has a sequence as its default value, use something like
-the following:
+To define a column that has a sequence as its default value, use something like the following:
 
 ```ruby
 Sequel.migration do
   change do
-    create_sequence :position_id
+    create_sequence :position_id, if_exists: false, start: 1
 
     create_table(:things) do
       primary_key :id
       String :name, text: true
 
       # PostgreSQL uses bigint as the sequence's default type.
-      Bignum :position, null: false
+      Bignum :position
 
       Time :created_at, null: false
       Time :updated_at, null: false
@@ -82,6 +83,24 @@ DB.lastval("position")
 DB.setval("position", 1234)
 ```
 
+## Usage with SQLite
+
+In SQLite, the sequence functionality is implemented by registering tables in the database with a primary key of `id` and an additional integer field `fiction`.
+```sql
+CREATE TABLE `name_of_your_sequence_table`
+(id integer primary key autoincrement, fiction integer);
+```
+
+You might utilize the last one as a numeric label to collect statistics on the operation of the end-to-end counter `"name_of_your_sequence_table".id` within the application. 
+
+```ruby
+DB.nextval_with_label("position", 1)
+```
+
+By default, `fiction` has a zero value.
+
+Otherwise, the operation of this gem for SQLite is identical to the ways of using Sequence in more advanced databases.
+
 ## Maintainer
 
 - [Nikolai Bocharov](https://github.com/oreol-group)

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

@@ -20,9 +20,10 @@ module Sequel
 
         def create_sequence(name, options = {})
           increment = options[:increment] || options[:step]
+          if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
 
-          sql = ["CREATE SEQUENCE IF NOT EXISTS #{name}"]
+          sql = ["CREATE SEQUENCE #{if_exists} #{name}"]
           sql << "INCREMENT BY #{increment}" if increment
           sql << "START WITH #{options[:start]}" if options[:start]
           sql << ';'
@@ -32,7 +33,7 @@ module Sequel
 
         def drop_sequence(name)
           name = quote_name(name.to_s)
-          sql = "DROP SEQUENCE #{name}"
+          sql = "DROP SEQUENCE IF EXISTS #{name}"
           run(sql)
         end
 

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

@@ -35,9 +35,10 @@ module Sequel
 
         def create_sequence(name, options = {})
           increment = options[:increment] || options[:step]
+          if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
 
-          sql = ["CREATE SEQUENCE IF NOT EXISTS #{name}"]
+          sql = ["CREATE SEQUENCE #{if_exists} #{name}"]
           sql << "INCREMENT BY #{increment}" if increment
           sql << "START WITH #{options[:start]}" if options[:start]
           sql << ';'
@@ -48,7 +49,7 @@ module Sequel
 
         def drop_sequence(name)
           name = quote_name(name.to_s)
-          sql = "DROP SEQUENCE #{name}"
+          sql = "DROP SEQUENCE IF EXISTS #{name}"
           run(sql)
         end
 

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+# https://sequel.jeremyevans.net/rdoc/files/doc/sql_rdoc.html
+# https://github.com/jeremyevans/sequel/blob/master/lib/sequel/database/connecting.rb
+module Sequel
+  module Sequence
+    module Database
+      module SQLite
+        def check_sequences
+          fetch('SELECT * FROM `sqlite_sequence`;').all.to_a
+        end
+
+        def create_sequence(name, options = {})
+          check_options(options)
+          if_exists = build_exists_condition(options[:if_exists])
+          start_option = options[:start] || 1
+          sql = [create_sequence_table(stringify(name), if_exists)]
+          sql << insert_into_sqlite_sequence(stringify(name), start_option)
+          run(sql.join("\n"))
+        end
+
+        def drop_sequence(name, options = {})
+          if_exists = build_exists_condition(options[:if_exists])
+          run(drop_sequence_table(stringify(name), if_exists))
+        end
+
+        def nextval(name)
+          run(insert_into_sequence_table(stringify(name), 0))
+          take_seq(name)
+        end
+
+        def nextval_with_label(name, num_label = 0)
+          run(insert_into_sequence_table(stringify(name), num_label))
+          take_seq(name)
+        end
+
+        def lastval(name)
+          take_seq(stringify(name))
+        end
+
+        alias currval lastval
+
+        def setval(name, value)
+          current = lastval(stringify(name))
+          if current.nil?
+            create_sequence(stringify(name), { start: value })
+          elsif value < current
+            # sql = [delete_from_sqlite_sequence(name)]
+            # sql << drop_sequence_table(name)
+            # sql << insert_into_sqlite_sequence(name, value)
+            # run(sql.join("\n"))
+            log_info DANGER_OPT_ID
+            value = current
+          else
+            run(insert_into_sqlite_sequence(stringify(name), value))
+          end
+          value
+        end
+
+        def set_column_default_nextval(table, column, sequence)
+          run(create_sequenced_column(stringify(table),
+                                      stringify(column),
+                                      stringify(sequence)))
+        end
+
+        private
+
+        def stringify(name)
+          @name ||= {}
+          @name.fetch(name, nil) || (@name[name] = name.to_s)
+        end
+
+        def take_seq(name)
+          out = nil
+          fetch(select_max_seq(name)) do |row|
+            out = row[:id]
+          end
+          out
+        end
+
+        def create_sequence_table(name, if_exists = nil)
+          %(
+            CREATE TABLE #{if_exists || IF_NOT_EXISTS} #{name}
+            (id integer primary key autoincrement, fiction integer);
+          )
+        end
+
+        def insert_into_sequence_table(name, num_label)
+          "INSERT INTO #{name} (fiction) VALUES (#{num_label});"
+        end
+
+        def insert_into_sqlite_sequence(name, value)
+          current = take_seq(name)
+          if current.nil?
+            "INSERT INTO sqlite_sequence (name, seq) VALUES ('#{name}', #{value});"
+          else
+            %(
+              UPDATE sqlite_sequence
+              SET seq = #{[current, value].max}
+              WHERE name = '#{name}';
+            )
+          end
+        end
+
+        def delete_from_sqlite_sequence(name)
+          "DELETE FROM sqlite_sequence WHERE name = '#{name}';"
+        end
+
+        def drop_sequence_table(name, if_exists = nil)
+          "DROP TABLE #{if_exists || IF_EXISTS} #{name};"
+        end
+
+        def select_max_seq(name)
+          "SELECT MAX(seq) AS id FROM sqlite_sequence WHERE name = '#{name}';"
+        end
+
+        def create_sequenced_column(table, column, sequence)
+          %(
+            CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} AFTER INSERT
+            ON #{table}
+            BEGIN
+              INSERT INTO #{sequence}(fiction) VALUES (0);
+              UPDATE #{table}
+              SET #{column} = (SELECT MAX(seq) FROM sqlite_sequence WHERE name = '#{sequence}')
+              WHERE rowid = NEW.rowid;
+            END;
+          )
+        end
+      end
+    end
+  end
+end

data/lib/sequel/sequence/database.rb

@@ -3,6 +3,16 @@
 module Sequel
   module Sequence
     module Database
+      DANGER_OPT_ID = "Warning! The new sequence ID can't be less than the current one."
+      DANGER_OPT_INCREMENT = 'Warning! Increments greater than 1 are not supported.'
+      IF_EXISTS = 'IF EXISTS'
+      IF_NOT_EXISTS = 'IF NOT EXISTS'
+
+      def check_options(params)
+        log_info DANGER_OPT_INCREMENT if params[:increment] && params[:increment] != 1
+        log_info DANGER_OPT_INCREMENT if params[:step] && params[:step] != 1
+      end
+
       def custom_sequence?(_sequence_name)
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
@@ -15,7 +25,7 @@ module Sequel
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
 
-      def drop_sequence(_name)
+      def drop_sequence(_name, _options = {})
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
 
@@ -35,6 +45,10 @@ module Sequel
         name.to_s.split('.', 2).map { |part| quote_sequence_name(part) }.join('.')
       end
 
+      def nextval_with_label(_name, _num_label = 0)
+        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+      end
+
       def nextval(_name)
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
@@ -50,6 +64,15 @@ module Sequel
       def setval(_name, _value)
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
+
+      def build_exists_condition(option)
+        case option
+        when true
+          IF_EXISTS
+        when false
+          IF_NOT_EXISTS
+        end
+      end
     end
   end
 end

data/lib/sequel/sequence/version.rb

@@ -2,6 +2,6 @@
 
 module Sequel
   module Sequence
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

data/lib/sequel/sequence.rb

@@ -4,6 +4,7 @@ require 'sequel/database'
 require 'sequel/adapters/postgres'
 # require 'sequel/adapters/mysql'
 require 'sequel/adapters/mysql2'
+require 'sequel/adapters/sqlite'
 require 'sequel/error'
 
 module Sequel
@@ -14,6 +15,7 @@ module Sequel
       require 'sequel/sequence/database/postgresql'
       # require "sequel/sequence/database/mysql"
       require 'sequel/sequence/database/mysql2'
+      require 'sequel/sequence/database/sqlite'
     end
   end
 end
@@ -30,3 +32,6 @@ Sequel::Mysql2::Database.include(
 # Sequel::Mysql::Database.include(
 #   Sequel::Sequence::Database::Mysql
 # )
+Sequel::SQLite::Database.include(
+  Sequel::Sequence::Database::SQLite
+)

data/sequel-sequence.gemspec

@@ -37,9 +37,11 @@ Gem::Specification.new do |spec|
     # JRuby Adapter Dependencies
     spec.add_development_dependency 'jdbc-mysql', '~> 8.0.17'
     spec.add_development_dependency 'jdbc-postgres', '~> 42.2.14'
+    spec.add_development_dependency 'jdbc-sqlite3', '~> 3.42'
   else
     # MRI/Rubinius Adapter Dependencies
     spec.add_development_dependency 'mysql2', '~> 0.5.3'
     spec.add_development_dependency 'pg', '~> 1.5.4'
+    spec.add_development_dependency 'sqlite3', '~> 1.6.0'
   end
 end

data/test/sequel/mysql_sequence_test.rb

@@ -72,7 +72,7 @@ class MysqlSequenceTest < Minitest::Test
     assert_equal 3, MysqlDB.nextval(:position)
   end
 
-  test 'returns current/last sequence value without incrementing it' do
+  test "returns current/last sequence value, which doesn't increase by itself" do
     with_migration do
       def up
         create_sequence :position
@@ -126,7 +126,7 @@ class MysqlSequenceTest < Minitest::Test
     end.down
 
     sequence = MysqlDB.check_sequences.find do |seq|
-      seq[:sequence_name] == 'position'
+      seq[:Tables_in_test] == 'position'
     end
 
     assert_nil sequence
@@ -157,7 +157,7 @@ class MysqlSequenceTest < Minitest::Test
     with_migration do
       def up
         drop_table :builders, if_exists: true
-        create_sequence :position_id, if_exists: false
+        create_sequence :position_id, if_exists: false, start: 1
         create_table :builders do
           primary_key :id
           String :name, text: true

data/test/sequel/postgresql_sequence_test.rb

@@ -72,7 +72,7 @@ class PostgresqlSequenceTest < Minitest::Test
     assert_equal 3, PostgresqlDB.nextval(:position)
   end
 
-  test 'returns current (or last as alias) sequence value without incrementing it' do
+  test "returns current/last sequence value, which doesn't increase by itself" do
     with_migration do
       def up
         create_sequence :position, start: 2, increment: 2
@@ -164,7 +164,7 @@ class PostgresqlSequenceTest < Minitest::Test
     with_migration do
       def up
         drop_table :masters, if_exists: true
-        create_sequence :position_id, if_exists: false
+        create_sequence :position_id, if_exists: false, start: 1
         create_table :masters, if_not_exists: true do
           primary_key :id
           String :name, text: true

data/test/sequel/sqlite_sequence_test.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+require 'sqlite_test_helper'
+
+class SqliteSequenceTest < Minitest::Test
+  include SqliteTestHelper
+
+  setup do
+    recreate_table
+  end
+
+  test 'adds sequence with default values' do
+    with_migration do
+      def up
+        # create_sequence :position, {start: 1, increment: 1} - default values
+        create_sequence :position
+      end
+    end.up
+
+    assert_equal 2, SQLiteDB.nextval(:position)
+    assert_equal 3, SQLiteDB.nextval(:position)
+  end
+
+  test 'adds sequence reader within model and its inherited class' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    class Object < Sequel::Model; end
+
+    assert_equal 2, Object.db.nextval('position')
+    assert_equal 3, Object.db.nextval('position')
+
+    class InheritedObject < Object; end
+
+    assert_equal 4, InheritedObject.db.nextval(:position)
+    assert_equal 5, InheritedObject.db.nextval(:position)
+  end
+
+  test 'adds sequence starting at 100' do
+    with_migration do
+      def up
+        create_sequence :position, start: 100
+      end
+    end.up
+
+    assert_equal 101, SQLiteDB.nextval(:position)
+    assert_equal 102, SQLiteDB.nextval(:position)
+  end
+
+  test 'adds a sequence that we are trying to increase by a value greater than 1' do
+    @step = 4
+    with_migration do
+      def up
+        create_sequence :position, increment: 4
+      end
+    end.up
+
+    assert_equal 2, SQLiteDB.nextval(:position)
+    assert_equal 3, SQLiteDB.nextval(:position)
+    assert_operator (2 + @step), :>, SQLiteDB.nextval(:position)
+  end
+
+  test 'adds a sequence that we are trying to increase by a value greater than 1 (using :step alias)' do
+    @step = 4
+    with_migration do
+      def up
+        create_sequence :position, step: 4
+      end
+    end.up
+
+    assert_equal 2, SQLiteDB.nextval(:position)
+    assert_equal 3, SQLiteDB.nextval(:position)
+    assert_operator (2 + @step), :>, SQLiteDB.nextval(:position)
+  end
+
+  test "returns current/last sequence value, which doesn't increase by itself" do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    SQLiteDB.nextval(:position)
+    # changed value (=2) after default one (=1)
+
+    assert_equal 2, SQLiteDB.currval(:position)
+    assert_equal 2, SQLiteDB.lastval(:position)
+    assert_equal 2, SQLiteDB.currval(:position)
+    assert_equal 2, SQLiteDB.lastval(:position)
+  end
+
+  test 'sets a new sequence value greater than the current one' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    assert_equal SQLiteDB.currval(:position), 1
+
+    SQLiteDB.nextval(:position)
+    assert_equal SQLiteDB.currval(:position), 2
+
+    SQLiteDB.setval(:position, 101)
+    assert_equal 101, SQLiteDB.lastval(:position)
+
+    SQLiteDB.nextval(:position)
+    assert_equal 102, SQLiteDB.lastval(:position)
+  end
+
+  test 'sets a new sequence value less than the current one' do
+    with_migration do
+      def up
+        create_sequence :position, start: 100
+      end
+    end.up
+
+    assert_equal SQLiteDB.currval(:position), 100
+
+    SQLiteDB.nextval(:position)
+    assert_equal SQLiteDB.currval(:position), 101
+
+    SQLiteDB.setval(:position, 1)
+    assert_equal 101, SQLiteDB.lastval(:position)
+
+    SQLiteDB.nextval(:position)
+    assert_equal 102, SQLiteDB.lastval(:position)
+  end
+
+  test 'sets a new sequence value with a label' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    SQLiteDB.nextval(:position)
+    SQLiteDB.nextval_with_label(:position, 1)
+    SQLiteDB.nextval_with_label(:position, 1)
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position where fiction = 1;').all.size
+    assert_equal 2, fiction_set_size
+
+    fiction_set_size = SQLiteDB.fetch('SELECT * FROM position where fiction = 0;').all.size
+    assert_equal 1, fiction_set_size
+  end
+
+  test 'drops the sequence and the check_sequences' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    sequence = SQLiteDB.check_sequences.find_all do |seq|
+      seq[:name] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    with_migration do
+      def down
+        drop_sequence :position
+      end
+    end.down
+
+    sequence = SQLiteDB.check_sequences.find do |seq|
+      seq[:name] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'dropsthe sequence with the parameter if_exists' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    sequence = SQLiteDB.check_sequences.find_all do |seq|
+      seq[:name] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    with_migration do
+      def down
+        drop_sequence :position, if_exists: true
+      end
+    end.down
+
+    sequence = SQLiteDB.check_sequences.find do |seq|
+      seq[:name] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'orders sequences' do
+    list = SQLiteDB.check_sequences.map { |s| s[:name] }
+    assert !list.include?('a')
+    assert !list.include?('b')
+    assert !list.include?('c')
+
+    with_migration do
+      def up
+        drop_table :things, if_exists: true
+        create_sequence :c, { start: 1 }
+        create_sequence :a, { start: 3 }
+        create_sequence :b
+      end
+    end.up
+
+    list = SQLiteDB.check_sequences.map { |s| s[:name] }
+    assert list.include?('a')
+    assert list.include?('b')
+    assert list.include?('c')
+  end
+
+  test 'creates table that references sequence' do
+    with_migration do
+      def up
+        drop_table :apprentices, if_exists: true
+        create_sequence :position_id, if_exists: false, start: 1
+        create_table :apprentices do
+          primary_key :id
+          String :name, text: true
+          Bignum :position
+        end
+        set_column_default_nextval :apprentices, :position, :position_id
+      end
+    end.up
+
+    class Apprentice < Sequel::Model; end
+
+    apprentice1 = Apprentice.create(name: 'Apprentice 1')
+    pos1 = SQLiteDB.lastval(:position_id) - 1
+    assert_equal pos1, apprentice1.reload.position
+
+    apprentice2 = Apprentice.create(name: 'Apprentice 2')
+    pos2 = SQLiteDB.currval(:position_id) - 1
+    assert_equal pos2, apprentice2.reload.position
+
+    assert_equal pos2 - pos1, 1
+
+    SQLiteDB.nextval(:position_id)
+
+    apprentice4 = Apprentice.create(name: 'Apprentice 4')
+    pos4 = SQLiteDB.currval(:position_id) - 1
+    assert_equal pos4, apprentice4.reload.position
+
+    assert_equal pos4 - pos2, 2
+  end
+end

data/test/sqlite_test_helper.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'logger'
+
+SQLiteDB = Sequel.connect(
+  "sqlite://#{ENV.fetch('TEST_SQLITE_DATABASE', nil) || 'db/test.sqlite3'}",
+  loggers: [Logger.new($stdout)]
+)
+
+module SqliteTestHelper
+  def recreate_table
+    SQLiteDB.drop_sequence 'position'
+    SQLiteDB.run 'DROP TABLE IF EXISTS objects'
+    SQLiteDB.drop_sequence 'a'
+    SQLiteDB.drop_sequence 'b'
+    SQLiteDB.drop_sequence 'c'
+    sql = 'CREATE TABLE objects (id INTEGER PRIMARY KEY AUTOINCREMENT, quantity INTEGER DEFAULT(0), slug VARCHAR(255));'
+    SQLiteDB.run sql
+  end
+
+  def with_migration(&block)
+    migration_class = Sequel::Migration
+
+    Sequel::Model.db = SQLiteDB
+
+    Class.new(migration_class, &block).new(SQLiteDB)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-sequence
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Nikolai Bocharov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-14 00:00:00.000000000 Z
+date: 2023-09-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -142,6 +142,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.4
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.6.0
 description: |2
       This gem provides a single interface for SEQUENCE functionality
       in Postgresql and Mysql databases within the Sequel ORM.
@@ -174,12 +188,15 @@ files:
 - lib/sequel/sequence/database/mysql.rb
 - lib/sequel/sequence/database/mysql2.rb
 - lib/sequel/sequence/database/postgresql.rb
+- lib/sequel/sequence/database/sqlite.rb
 - lib/sequel/sequence/version.rb
 - sequel-sequence.gemspec
 - test/mysql_test_helper.rb
 - test/postgresql_test_helper.rb
 - test/sequel/mysql_sequence_test.rb
 - test/sequel/postgresql_sequence_test.rb
+- test/sequel/sqlite_sequence_test.rb
+- test/sqlite_test_helper.rb
 - test/test_helper.rb
 homepage: https://rubygems.org/gems/sequel-sequence
 licenses: