sequel-sequence 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba4270613514ab8a88b24fa9034314333feba102dff7719a8e238ca1c84e67d1
-  data.tar.gz: 950c6494e0c9f55f6465beee78209649c784508c9c9c0dab1b9817576cbf3a7c
+  metadata.gz: 749ea113ce41f1f7f70f620d5aa70deac470a76491cdb36b4bd8e5c739487a07
+  data.tar.gz: 9628bc8f57ad5a1ead78d82eaa8348963876c93a6be40df0d8c9dabfab928f76
 SHA512:
-  metadata.gz: ed1505fd942d5247ea8ad64b47e1caa9cc420826ace83e4f8c075db257090576772219aa9f48007a0c9d84793f127ec82604a310688717b18ece0ceec8824d66
-  data.tar.gz: c781c917e87029eec161ae656bb331552e6e0f531ceb8c6f3df8b836686f9f1bc7a4f277f81c15a9c515f2861624ed73f978a7be7b7db35d29a32c09aef277f5
+  metadata.gz: d0dbf107132dad0bcd23bcf5da23cb9fb121119dafb109865978a6bf26fe8465985875fd6d33b72422cd57e1d5b74b54fce065ba7a2fdf21b0d76f032b7c149e
+  data.tar.gz: bd1bbeaf56ddcd37b4bc86b6b83ad06e85212c7f09bb32db03004bfc9599dd240b141ea6c6130d64fe8b85471c3e6bb7cd8537714b7b6f34f744142b117ce606

data/.github/workflows/ci.yml

@@ -126,5 +126,8 @@ jobs:
         env:
           TEST_SQLITE_DATABASE: "db/test.sqlite3"
 
+      - name: Run Mock Tests
+        run: bundle exec rake TEST=test/sequel/mock_sequence_test.rb
+
       - name: Run Rubocop
         run: bundle exec rake rubocop

data/CHANGELOG.md

@@ -11,6 +11,13 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v0.4.1 - 2023-09-28
+
+- [Added] Important notice to README.md.
+- [Added] MySQL tests cover 100%.
+- [Added] SQLite tests cover 100%.
+- [Added] Mock connection to check for additional ORM exceptions.
+
 ## v0.4.0 - 2023-09-26
 
 - [Fixed] Differences between MySQL and MariaDB.

data/CONTRIBUTING.md

@@ -235,4 +235,5 @@ $ bundle exec rake TEST=test/sequel/postgresql_sequence_test.rb
 $ bundle exec rake TEST=test/sequel/mariadb_sequence_test.rb
 $ bundle exec rake TEST=test/sequel/mysql_sequence_test.rb
 $ bundle exec rake TEST=test/sequel/sqlite_sequence_test.rb
+$ bundle exec rake TEST=test/sequel/mock_sequence_test.rb
 ```

data/README.md

@@ -48,7 +48,7 @@ Sequel.migration do
 end
 ```
 
-You can also specify the initial value and increment:
+You can also specify the following optional parameters: `if_exists` – a condition of acceptability; `start` – an initial value; `increment` or `step` – step size to the next auto incrementing value:
 
 ```ruby
 create_sequence :position, increment: 2
@@ -107,7 +107,7 @@ CREATE TABLE `name_of_your_sequence_table`
 (id integer primary key autoincrement, fiction integer);
 ```
 
-You might utilize the last field 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. 
+You might utilize the last field `fiction` 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
 create_sequence :position, if_exists: false, start: 1000, numeric_label: 1
 ```
@@ -120,6 +120,10 @@ By default, `fiction` has a zero value.
 
 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.
 
+## Known issues you may encounter
+
+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.
+
 ## Maintainer
 
 - [Nikolai Bocharov](https://github.com/oreol-group)

data/Rakefile

@@ -9,7 +9,8 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.test_files = FileList['test/sequel/postgresql_sequence_test.rb',
                           'test/sequel/mariadb_sequence_test.rb',
-                          'test/sequel/sqlite_sequence_test.rb']
+                          'test/sequel/sqlite_sequence_test.rb',
+                          'test/sequel/mock_sequence_test.rb']
 end
 
 Rake::TestTask.new(:mysql) do |t|
@@ -18,6 +19,30 @@ Rake::TestTask.new(:mysql) do |t|
   t.test_files = FileList['test/sequel/mysql_sequence_test.rb']
 end
 
+Rake::TestTask.new(:postgresql) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/postgresql_sequence_test.rb']
+end
+
+Rake::TestTask.new(:mariadb) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/mariadb_sequence_test.rb']
+end
+
+Rake::TestTask.new(:sqlite) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/sqlite_sequence_test.rb']
+end
+
+Rake::TestTask.new(:mock) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/mock_sequence_test.rb']
+end
+
 RuboCop::RakeTask.new
 
 task default: %i[test rubocop]

data/lib/sequel/error.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Sequel
-  class MethodNotAllowed < StandardError
-    METHOD_NOT_ALLOWED = 'Method not allowed'
+  (
+    # Error raised when attempting to utilize an invalid adapter to SEQUENCE interface.
+    MethodNotAllowed = Class.new(Error)
+  ).name
 
-    # Initialize a new Error object
-    def initialize(message = '')
-      super(message)
-    end
+  class Database
+    METHOD_NOT_ALLOWED = 'Method not allowed'
   end
 end

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

@@ -1,71 +1,79 @@
 # frozen_string_literal: true
 
-module Mariadb
-  def quote_column_name(name)
-    "`#{name.gsub('`', '``')}`"
-  end
+module Sequel
+  module Sequence
+    module Database
+      module Server
+        module Mariadb
+          def quote_column_name(name)
+            "`#{name.gsub('`', '``')}`"
+          end
 
-  def quote_sequence_name(name)
-    "`#{name.gsub(/[`"']/, '')}`"
-  end
+          def quote_sequence_name(name)
+            "`#{name.gsub(/[`"']/, '')}`"
+          end
 
-  def check_sequences
-    fetch("SHOW FULL TABLES WHERE Table_type = 'SEQUENCE';").all.to_a
-  end
+          def check_sequences
+            fetch("SHOW FULL TABLES WHERE Table_type = 'SEQUENCE';").all.to_a
+          end
 
-  def create_sequence(name, options = {})
-    increment = options[:increment] || options[:step]
-    if_exists = build_exists_condition(options[:if_exists])
-    name = quote_name(name.to_s)
+          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_exists || Sequel::Database::IF_NOT_EXISTS} #{name}"]
-    sql << "INCREMENT BY #{increment}" if increment
-    sql << "START WITH #{options[:start]}" if options[:start]
-    sql << ';'
+            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 << ';'
 
-    run(sql.join("\n"))
-  end
+            run(sql.join("\n"))
+          end
 
-  def drop_sequence(name)
-    name = quote_name(name.to_s)
-    sql = "DROP SEQUENCE IF EXISTS #{name}"
-    run(sql)
-  end
+          def drop_sequence(name)
+            name = quote_name(name.to_s)
+            sql = "DROP SEQUENCE IF EXISTS #{name}"
+            run(sql)
+          end
 
-  def nextval(name)
-    name = quote(name.to_s)
-    out = nil
-    fetch("SELECT nextval(#{name});") do |row|
-      out = row["nextval(#{name})".to_sym]
-    end
-    out
-  end
+          def nextval(name)
+            name = quote(name.to_s)
+            out = nil
+            fetch("SELECT nextval(#{name});") do |row|
+              out = row["nextval(#{name})".to_sym]
+            end
+            out
+          end
 
-  def lastval(name)
-    name = quote(name.to_s)
-    out = nil
-    fetch("SELECT lastval(#{name});") do |row|
-      out = row["lastval(#{name})".to_sym]
-    end
-    out
-  end
+          def lastval(name)
+            name = quote(name.to_s)
+            out = nil
+            fetch("SELECT lastval(#{name});") do |row|
+              out = row["lastval(#{name})".to_sym]
+            end
+            out
+          end
 
-  alias currval lastval
+          alias currval lastval
 
-  def setval(name, value)
-    name = quote(name.to_s)
-    out = nil
-    fetch("SELECT setval(#{name}, #{value});") do |row|
-      out = row["setval(#{name}, #{value})".to_sym]
-    end
-    out
-  end
+          def setval(name, value)
+            name = quote(name.to_s)
+            out = nil
+            fetch("SELECT setval(#{name}, #{value});") do |row|
+              out = row["setval(#{name}, #{value})".to_sym]
+            end
+            out
+          end
 
-  def set_column_default_nextval(table, column, sequence)
-    table = table.to_s
-    column = column.to_s
-    sequence = quote(sequence.to_s)
-    run "ALTER TABLE IF EXISTS #{table} " \
-        "ALTER COLUMN #{column} SET DEFAULT nextval(#{sequence});"
+          def set_column_default_nextval(table, column, sequence)
+            table = table.to_s
+            column = column.to_s
+            sequence = quote(sequence.to_s)
+            run "ALTER TABLE IF EXISTS #{table} " \
+                "ALTER COLUMN #{column} SET DEFAULT nextval(#{sequence});"
+          end
+        end
+      end
+    end
   end
 end

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

@@ -1,178 +1,185 @@
 # frozen_string_literal: true
 
-module Mysql
-  def check_sequences
-    fetch('SELECT * FROM mysql_sequence;').all.to_a
-  end
-
-  def custom_sequence?(sequence_name)
-    out = nil
-    begin
-      fetch(select_from_mysql_sequence_where(stringify(sequence_name))) do |row|
-        out = row[:name]
-      end
-    rescue Sequel::DatabaseError
-      return false
-    end
-
-    !out.nil?
-  end
-
-  def create_sequence(name, options = {})
-    check_options(options)
-    if_exists = build_exists_condition(options[:if_exists])
-    start_option = options[:start] || 1
-    num_label = options[:numeric_label] || 0
-    return if (current = lastval(name)) && (current >= start_option)
-
-    run create_sequence_table(stringify(name), if_exists)
-    run insert_into_sequence_table_init_values(stringify(name), start_option, num_label)
-    run create_mysql_sequence
-    table_matcher { run delete_from_mysql_sequence(stringify(name)) }
-    run insert_into_mysql_sequence(stringify(name), start_option)
-  end
-
-  def drop_sequence(name, options = {})
-    if_exists = build_exists_condition(options[:if_exists])
-    run drop_sequence_table(stringify(name), if_exists)
-    table_matcher { run delete_from_mysql_sequence(stringify(name)) }
-  end
-
-  def nextval(name)
-    run insert_into_sequence_table(stringify(name), 0)
-    table_matcher { run delete_from_mysql_sequence(stringify(name)) }
-    run insert_last_insert_id_into_mysql_sequence(stringify(name))
-    take_seq(stringify(name))
-  end
-
-  def nextval_with_label(name, num_label = 0)
-    run insert_into_sequence_table(stringify(name), num_label)
-    table_matcher { run delete_from_mysql_sequence(stringify(name)) }
-    run insert_last_insert_id_into_mysql_sequence(stringify(name))
-    take_seq(stringify(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
-      log_info Sequel::Database::DANGER_OPT_ID
-      value = current
-    elsif value > current
-      run insert_into_sequence_table_init_values(stringify(name), value, 0)
-      table_matcher { run delete_from_mysql_sequence(stringify(name)) }
-      run insert_into_mysql_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))
-    run update_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 select_from_mysql_sequence_where(name)
-    "SELECT * FROM mysql_sequence where name = '#{name}';"
-  end
-
-  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);
-    ).strip
-  end
-
-  def insert_into_sequence_table_init_values(name, start_id, num_label)
-    "INSERT INTO #{name} (id, fiction) VALUES (#{start_id}, #{num_label});"
-  end
-
-  def create_mysql_sequence
-    %(
-      CREATE TABLE #{Sequel::Database::IF_NOT_EXISTS} mysql_sequence
-      (name VARCHAR(40), seq INT);
-    ).strip
-  end
-
-  def select_max_seq(name)
-    "SELECT MAX(seq) AS id FROM mysql_sequence WHERE name = '#{name}';"
-  end
-
-  def take_seq(name)
-    table_matcher do
-      out = nil
-      fetch(select_max_seq(name)) do |row|
-        out = row[:id]
+module Sequel
+  module Sequence
+    module Database
+      module Server
+        module Mysql
+          def check_sequences
+            fetch('SELECT * FROM mysql_sequence;').all.to_a
+          end
+
+          def custom_sequence?(sequence_name)
+            table_matcher do
+              out = nil
+              fetch(select_from_mysql_sequence_where(stringify(sequence_name))) do |row|
+                out = row[:name]
+              end
+              !out.nil?
+            end || false
+          end
+
+          def create_sequence(name, options = {})
+            check_options(options)
+            if_exists = build_exists_condition(options[:if_exists])
+            start_option = options[:start] || 1
+            num_label = options[:numeric_label] || 0
+            return if (current = lastval(name)) && (current >= start_option)
+
+            run create_sequence_table(stringify(name), if_exists)
+            run insert_into_sequence_table_init_values(stringify(name), start_option, num_label)
+            run create_mysql_sequence
+            table_matcher { run delete_from_mysql_sequence(stringify(name)) }
+            run insert_into_mysql_sequence(stringify(name), start_option)
+          end
+
+          def drop_sequence(name, options = {})
+            if_exists = build_exists_condition(options[:if_exists])
+            run drop_sequence_table(stringify(name), if_exists)
+            table_matcher { run delete_from_mysql_sequence(stringify(name)) }
+          end
+
+          def nextval(name)
+            run insert_into_sequence_table(stringify(name), 0)
+            table_matcher { run delete_from_mysql_sequence(stringify(name)) }
+            run insert_last_insert_id_into_mysql_sequence(stringify(name))
+            take_seq(stringify(name))
+          end
+
+          def nextval_with_label(name, num_label = 0)
+            run insert_into_sequence_table(stringify(name), num_label)
+            table_matcher { run delete_from_mysql_sequence(stringify(name)) }
+            run insert_last_insert_id_into_mysql_sequence(stringify(name))
+            take_seq(stringify(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
+              log_info Sequel::Database::DANGER_OPT_ID
+              value = current
+            elsif value > current
+              run insert_into_sequence_table_init_values(stringify(name), value, 0)
+              table_matcher { run delete_from_mysql_sequence(stringify(name)) }
+              run insert_into_mysql_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))
+            run update_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 select_from_mysql_sequence_where(name)
+            "SELECT * FROM mysql_sequence where name = '#{name}';"
+          end
+
+          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);
+            ).strip
+          end
+
+          def insert_into_sequence_table_init_values(name, start_id, num_label)
+            "INSERT INTO #{name} (id, fiction) VALUES (#{start_id}, #{num_label});"
+          end
+
+          def create_mysql_sequence
+            %(
+              CREATE TABLE #{Sequel::Database::IF_NOT_EXISTS} mysql_sequence
+              (name VARCHAR(40), seq INT);
+            ).strip
+          end
+
+          def select_max_seq(name)
+            "SELECT MAX(seq) AS id FROM mysql_sequence WHERE name = '#{name}';"
+          end
+
+          def take_seq(name)
+            table_matcher do
+              out = nil
+              fetch(select_max_seq(name)) do |row|
+                out = row[:id]
+              end
+              out
+            end
+          end
+
+          def delete_from_mysql_sequence(name)
+            "DELETE QUICK IGNORE FROM mysql_sequence WHERE name = '#{name}';"
+          end
+
+          def insert_into_mysql_sequence(name, value)
+            "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', #{value});"
+          end
+
+          def drop_sequence_table(name, if_exists = nil)
+            "DROP TABLE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
+          end
+
+          def insert_into_sequence_table(name, num_label)
+            "INSERT INTO #{name} (fiction) VALUES (#{num_label});"
+          end
+
+          def insert_last_insert_id_into_mysql_sequence(name)
+            "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', LAST_INSERT_ID());"
+          end
+
+          def create_sequenced_column(table, _column, sequence)
+            %(
+              CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} BEFORE INSERT
+              ON #{table}
+              FOR EACH ROW BEGIN
+                DELETE QUICK IGNORE FROM mysql_sequence WHERE name = '#{sequence}';
+                INSERT INTO #{sequence} SET fiction = 0;
+                INSERT INTO mysql_sequence SET name = '#{sequence}', seq = LAST_INSERT_ID();
+
+              END;
+            ).strip
+          end
+
+          def update_sequenced_column(table, column, sequence)
+            %(
+              CREATE TRIGGER IF NOT EXISTS #{table}_#{column} BEFORE INSERT
+              ON #{table}
+              FOR EACH ROW FOLLOWS #{table}_#{sequence}
+              SET NEW.#{column} = ( SELECT MAX(seq) FROM mysql_sequence WHERE name = '#{sequence}' );
+            ).strip
+          end
+
+          def table_matcher(&block)
+            block.call
+          rescue Sequel::DatabaseError => e
+            return if e.message =~ /\AMysql2::Error: Table(.)*doesn't exist\z/
+
+            # :nocov:
+            raise e
+            # :nocov:
+          end
+        end
       end
-      out
     end
   end
-
-  def delete_from_mysql_sequence(name)
-    "DELETE QUICK IGNORE FROM mysql_sequence WHERE name = '#{name}';"
-  end
-
-  def insert_into_mysql_sequence(name, value)
-    "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', #{value});"
-  end
-
-  def drop_sequence_table(name, if_exists = nil)
-    "DROP TABLE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
-  end
-
-  def insert_into_sequence_table(name, num_label)
-    "INSERT INTO #{name} (fiction) VALUES (#{num_label});"
-  end
-
-  def insert_last_insert_id_into_mysql_sequence(name)
-    "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', LAST_INSERT_ID());"
-  end
-
-  def create_sequenced_column(table, _column, sequence)
-    %(
-      CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} BEFORE INSERT
-      ON #{table}
-      FOR EACH ROW BEGIN
-        DELETE QUICK IGNORE FROM mysql_sequence WHERE name = '#{sequence}';
-        INSERT INTO #{sequence} SET fiction = 0;
-        INSERT INTO mysql_sequence SET name = '#{sequence}', seq = LAST_INSERT_ID();
-
-      END;
-    ).strip
-  end
-
-  def update_sequenced_column(table, column, sequence)
-    %(
-      CREATE TRIGGER IF NOT EXISTS #{table}_#{column} BEFORE INSERT
-      ON #{table}
-      FOR EACH ROW FOLLOWS #{table}_#{sequence}
-      SET NEW.#{column} = ( SELECT MAX(seq) FROM mysql_sequence WHERE name = '#{sequence}' );
-    ).strip
-  end
-
-  def table_matcher(&block)
-    block.call
-  rescue Sequel::DatabaseError => e
-    return if e.message =~ /\AMysql2::Error: Table(.)*doesn't exist\z/
-
-    raise e
-  end
 end

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

@@ -48,14 +48,10 @@ module Sequel
           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))
+            run(update_sqlite_sequence(stringify(name), value))
           end
           value
         end
@@ -96,21 +92,12 @@ module Sequel
           "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}';"
+        def update_sqlite_sequence(name, value)
+          %(
+            UPDATE sqlite_sequence
+            SET seq = #{value}
+            WHERE name = '#{name}';
+          )
         end
 
         def drop_sequence_table(name, if_exists = nil)

data/lib/sequel/sequence/database.rb

@@ -14,24 +14,24 @@ module Sequel
       end
 
       def custom_sequence?(_sequence_name)
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def check_sequences
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def create_sequence(_name, _options = {})
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def drop_sequence(_name, _options = {})
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def quote_name(name)
         unless respond_to?(:quote_column_name, false)
-          raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+          raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
         end
 
         name.to_s.split('.', 2).map { |part| quote_column_name(part) }.join('.')
@@ -39,30 +39,30 @@ module Sequel
 
       def quote(name)
         unless respond_to?(:quote_sequence_name, false)
-          raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+          raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
         end
 
         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
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def nextval(_name)
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       # for Postgres
       def currval(_name)
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       # for MariaDB
       alias lastval currval
 
       def setval(_name, _value)
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def build_exists_condition(option)

data/lib/sequel/sequence/database_ext_connection.rb

@@ -14,9 +14,13 @@ module Sequel
     define_singleton_method(:connect) do |*args|
       db = old_connect.call(*args)
       if db.adapter_scheme == :mysql2
-        @dbms = db.mariadb? ? Mariadb : Mysql
-        puts "Sequel::Database.REconnect mariadb? = #{db.mariadb?.inspect}"
-        puts "Sequel::Database.REconnect server_version = #{db.server_version.inspect}"
+        @dbms = if db.mariadb?
+                  Sequel::Sequence::Database::Server::Mariadb
+                else
+                  Sequel::Sequence::Database::Server::Mysql
+                end
+        db.log_info "Sequel::Database.connect (mariadb? = #{db.mariadb?.inspect})"
+        db.log_info "Sequel::Database.connect (server_version = #{db.server_version.inspect})"
         Sequel::Mysql2::Database.include(@dbms)
       end
       db

data/lib/sequel/sequence/version.rb

@@ -2,6 +2,6 @@
 
 module Sequel
   module Sequence
-    VERSION = '0.4.0'
+    VERSION = '0.4.1'
   end
 end

data/test/mock_test_helper.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+MockDB = Sequel.connect('mock://postgresql')

data/test/mysql_test_helper.rb

@@ -31,4 +31,9 @@ module MysqlTestHelper
 
     Class.new(migration_class, &block).new(MysqlDB)
   end
+
+  def sequence_table_exists?(name)
+    table_list = MysqlDB.fetch('SHOW TABLES;').all.map { |_key, value| value }
+    table_list.include?(name)
+  end
 end

data/test/sequel/mock_sequence_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'mock_test_helper'
+
+class MockSequenceTest < Minitest::Test
+  test 'checks check_options with params' do
+    mocked_method = Minitest::Mock.new
+    some_instance = MockDB
+
+    mocked_method.expect :call, true, [Sequel::Database::DANGER_OPT_INCREMENT]
+    some_instance.stub :log_info, mocked_method do
+      some_instance.check_options({ increment: 2 })
+    end
+    mocked_method.verify
+
+    mocked_method.expect :call, true, [Sequel::Database::DANGER_OPT_INCREMENT]
+    some_instance.stub :log_info, mocked_method do
+      some_instance.check_options({ step: 2 })
+    end
+    mocked_method.verify
+  end
+
+  test 'checks custom_sequence?' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.custom_sequence?(:position)
+    end
+  end
+
+  test 'checks check_sequences' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.check_sequences
+    end
+  end
+
+  test 'checks create_sequence' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.create_sequence(:position)
+    end
+  end
+
+  test 'checks drop_sequence' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.drop_sequence(:position)
+    end
+  end
+
+  test 'checks quote_name' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.quote_name(:position)
+    end
+  end
+
+  test 'checks quote' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.quote(:position)
+    end
+  end
+
+  test 'checks nextval_with_label' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.nextval_with_label(:position, 100)
+    end
+  end
+
+  test 'checks nextval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.nextval(:position)
+    end
+  end
+
+  test 'checks currval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.currval(:position)
+    end
+  end
+
+  test 'checks lastval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.lastval(:position)
+    end
+  end
+
+  test 'checks setval' do
+    assert_raises Sequel::MethodNotAllowed do
+      MockDB.setval(:position, 100)
+    end
+  end
+
+  test 'checks build_exists_condition for a true condition' do
+    assert_equal Sequel::Database::IF_EXISTS, MockDB.build_exists_condition(true)
+  end
+
+  test 'checks build_exists_condition for a false condition' do
+    assert_equal Sequel::Database::IF_NOT_EXISTS, MockDB.build_exists_condition(false)
+  end
+
+  test 'checks build_exists_condition for a non boolean condition' do
+    assert_nil MockDB.build_exists_condition('')
+  end
+end

data/test/sequel/mysql_sequence_test.rb

@@ -352,4 +352,20 @@ class MysqlSequenceTest < Minitest::Test
 
     assert_equal pos4 - pos2, 2
   end
+
+  test "catches a Mysql2::Error: «Table mysql_sequence doesn't exist»" do
+    assert !sequence_table_exists?('position')
+
+    MysqlDB.drop_table :mysql_sequence, if_exists: true
+
+    last_number = MysqlDB.lastval(:position)
+    assert_nil last_number
+  end
+
+  test 'creates a Sequence by calling DB.setval(position, 1) if it still does not exist' do
+    assert !sequence_table_exists?('position')
+
+    MysqlDB.setval(:position, 100)
+    assert_equal 100, MysqlDB.currval(:position)
+  end
 end

data/test/sequel/sqlite_sequence_test.rb

@@ -166,9 +166,7 @@ class SqliteSequenceTest < Minitest::Test
       end
     end.down
 
-    sequence = SQLiteDB.check_sequences.find do |seq|
-      seq[:name] == 'position'
-    end
+    sequence = (list = SQLiteDB.check_sequences).empty? ? nil : list
 
     assert_nil sequence
   end
@@ -192,9 +190,7 @@ class SqliteSequenceTest < Minitest::Test
       end
     end.down
 
-    sequence = SQLiteDB.check_sequences.find do |seq|
-      seq[:name] == 'position'
-    end
+    sequence = (list = SQLiteDB.check_sequences).empty? ? nil : list
 
     assert_nil sequence
   end
@@ -295,7 +291,6 @@ class SqliteSequenceTest < Minitest::Test
   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
@@ -326,4 +321,11 @@ class SqliteSequenceTest < Minitest::Test
 
     assert_equal pos4 - pos2, 2
   end
+
+  test 'creates a Sequence by calling DB.setval(position, 1) if it still does not exist' do
+    assert !sequence_table_exists?('position')
+
+    SQLiteDB.setval(:position, 100)
+    assert_equal 100, SQLiteDB.currval(:position)
+  end
 end

data/test/sqlite_test_helper.rb

@@ -10,9 +10,10 @@ SQLiteDB = Sequel.connect(
 
 module SqliteTestHelper
   def recreate_table
+    SQLiteDB.drop_table :apprentices, if_exists: true
     SQLiteDB.drop_sequence :position
     SQLiteDB.drop_sequence :position_id, if_exists: true
-    SQLiteDB.run 'DROP TABLE IF EXISTS objects'
+    SQLiteDB.drop_table :objects, if_exists: true
     SQLiteDB.drop_sequence 'a'
     SQLiteDB.drop_sequence 'b'
     SQLiteDB.drop_sequence 'c'
@@ -27,4 +28,10 @@ module SqliteTestHelper
 
     Class.new(migration_class, &block).new(SQLiteDB)
   end
+
+  def sequence_table_exists?(name)
+    sql = "SELECT name FROM sqlite_schema WHERE type ='table' AND name NOT LIKE 'sqlite_%';"
+    table_list = SQLiteDB.fetch(sql).all.map { |_key, value| value }
+    table_list.include?(name)
+  end
 end

data/test/test_helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'simplecov'
+
 SimpleCov.start
 
 require 'bundler/setup'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-sequence
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Nikolai Bocharov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-26 00:00:00.000000000 Z
+date: 2023-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -194,9 +194,11 @@ files:
 - lib/sequel/sequence/version.rb
 - sequel-sequence.gemspec
 - test/mariadb_test_helper.rb
+- test/mock_test_helper.rb
 - test/mysql_test_helper.rb
 - test/postgresql_test_helper.rb
 - test/sequel/mariadb_sequence_test.rb
+- test/sequel/mock_sequence_test.rb
 - test/sequel/mysql_sequence_test.rb
 - test/sequel/postgresql_sequence_test.rb
 - test/sequel/sqlite_sequence_test.rb