sequel-sequence 0.4.0 → 0.4.2

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(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

@@ -6,6 +6,11 @@ module Sequel
   module Sequence
     module Database
       module SQLite
+        def custom_sequence?(sequence_name)
+          sql = "SELECT * FROM `sqlite_sequence` WHERE name = '#{stringify(sequence_name)}';"
+          fetch(sql).all.size.positive?
+        end
+
         def check_sequences
           fetch('SELECT * FROM `sqlite_sequence`;').all.to_a
         end
@@ -44,18 +49,14 @@ module Sequel
         alias currval lastval
 
         def setval(name, value)
-          current = lastval(stringify(name))
+          current = lastval(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
+            log_info Sequel::Database::DANGER_OPT_ID
             value = current
           else
-            run(insert_into_sqlite_sequence(stringify(name), value))
+            run(update_sqlite_sequence(stringify(name), value))
           end
           value
         end
@@ -83,7 +84,7 @@ module Sequel
 
         def create_sequence_table(name, if_exists = nil)
           %(
-            CREATE TABLE #{if_exists || IF_NOT_EXISTS} #{name}
+            CREATE TABLE #{if_exists || Sequel::Database::IF_NOT_EXISTS} #{name}
             (id integer primary key autoincrement, fiction integer);
           )
         end
@@ -96,25 +97,16 @@ 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)
-          "DROP TABLE #{if_exists || IF_EXISTS} #{name};"
+          "DROP TABLE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
         end
 
         def select_max_seq(name)

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.2'
   end
 end

data/lib/sequel/sequence.rb

@@ -1,29 +1,61 @@
 # frozen_string_literal: true
 
 require 'sequel/database'
-require 'sequel/adapters/postgres'
-require 'sequel/adapters/mysql2'
-require 'sequel/adapters/sqlite'
 require 'sequel/error'
 require 'sequel/sequence/database_ext_connection'
 
 module Sequel
   module Sequence
     require 'sequel/sequence/database'
-
-    module Database
-      require 'sequel/sequence/database/postgresql'
-      require 'sequel/sequence/database/sqlite'
-    end
   end
 end
 
 Sequel::Database.include(
   Sequel::Sequence::Database
 )
-Sequel::Postgres::Database.include(
-  Sequel::Sequence::Database::PostgreSQL
-)
-Sequel::SQLite::Database.include(
-  Sequel::Sequence::Database::SQLite
-)
+
+begin
+  if Gem::Specification.find_by_name('pg')
+    require 'sequel/adapters/postgres'
+
+    module Sequel
+      module Sequence
+        module Database
+          require 'sequel/sequence/database/postgresql'
+        end
+      end
+    end
+
+    Sequel::Postgres::Database.include(
+      Sequel::Sequence::Database::PostgreSQL
+    )
+  end
+rescue Gem::LoadError
+  # do nothing
+end
+
+begin
+  require 'sequel/adapters/mysql2' if Gem::Specification.find_by_name('mysql2')
+rescue Gem::LoadError
+  # do nothing
+end
+
+begin
+  if Gem::Specification.find_by_name('sqlite3')
+    require 'sequel/adapters/sqlite'
+
+    module Sequel
+      module Sequence
+        module Database
+          require 'sequel/sequence/database/sqlite'
+        end
+      end
+    end
+
+    Sequel::SQLite::Database.include(
+      Sequel::Sequence::Database::SQLite
+    )
+  end
+rescue Gem::LoadError
+  # do nothing
+end

data/sequel-sequence.gemspec

@@ -9,7 +9,7 @@ Gem::Specification.new do |spec|
   spec.summary               = \
     'Adds SEQUENCE support to Sequel for migrations to PostgreSQL, MariaDB, MySQL and SQLite.'
   spec.description           = <<-DES
-    This gem provides a single interface for SEQUENCE functionality
+    This gem provides a single user-friendly interface for SEQUENCE functionality
     in Postgresql and MariaDB DBMS within the Sequel ORM.
     It also models the Sequences to meet the needs of SQLite and MySQL users.
   DES
@@ -27,22 +27,22 @@ Gem::Specification.new do |spec|
   spec.platform              = Gem::Platform::RUBY
   spec.required_ruby_version = '>= 2.7.0'
 
-  spec.add_dependency 'sequel', '>= 5.28', '<5.73'
+  spec.add_dependency 'sequel', '>= 5.28', '<6.0'
   spec.add_development_dependency 'bundler', '>= 2.2.4'
   spec.add_development_dependency 'minitest-utils', '~> 0.4.6'
   spec.add_development_dependency 'pry-byebug', '~> 3.10.1'
   spec.add_development_dependency 'rake', '~> 13.0.2'
   spec.add_development_dependency 'rubocop', '~> 1.56.3'
   spec.add_development_dependency 'simplecov', '~> 0.22.0'
-  if RUBY_ENGINE == 'jruby'
-    # 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
+  # if RUBY_ENGINE == 'jruby'
+  #   # 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/mariadb_test_helper.rb

@@ -13,7 +13,9 @@ MariaDB = Sequel.connect(
 
 module MariadbTestHelper
   def recreate_table
+    MariaDB.run 'DROP TABLE IF EXISTS builders'
     MariaDB.run 'DROP SEQUENCE IF EXISTS position'
+    MariaDB.run 'DROP SEQUENCE IF EXISTS position_id'
     MariaDB.run 'DROP TABLE IF EXISTS wares'
     MariaDB.run 'DROP SEQUENCE IF EXISTS a'
     MariaDB.run 'DROP SEQUENCE IF EXISTS b'

data/test/mock_test_helper.rb

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