sequel-sequence 0.2.0 → 0.4.0

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

@@ -0,0 +1,178 @@
+# 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]
+      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

@@ -0,0 +1,139 @@
+# 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
+          num_label = options[:numeric_label] || 0
+          return if (current = lastval(name)) && (current >= start_option)
+
+          sql = [create_sequence_table(stringify(name), if_exists)]
+          sql << insert_into_sequence_table_init_values(stringify(name), start_option, num_label)
+          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(stringify(name))
+        end
+
+        def nextval_with_label(name, num_label = 0)
+          run(insert_into_sequence_table(stringify(name), num_label))
+          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
+            # 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_init_values(name, start_id, num_label)
+          "INSERT INTO #{name} (id, fiction) VALUES (#{start_id}, #{num_label});"
+        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,21 +45,34 @@ 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
 
-      # for connection.adapter_name = "PostgreSQL"
+      # for Postgres
       def currval(_name)
         raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
       end
 
-      # for connection.adapter_name = "Mysql2"
+      # for MariaDB
       alias lastval currval
 
       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/database_ext_connection.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'database/server/mysql'
+require_relative 'database/server/mariadb'
+
+module Sequel
+  class Database
+    class << self
+      attr_reader :dbms
+    end
+
+    old_connect = singleton_method(:connect)
+
+    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}"
+        Sequel::Mysql2::Database.include(@dbms)
+      end
+      db
+    end
+  end
+end

data/lib/sequel/sequence/version.rb

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

data/lib/sequel/sequence.rb

@@ -2,9 +2,10 @@
 
 require 'sequel/database'
 require 'sequel/adapters/postgres'
-# require 'sequel/adapters/mysql'
 require 'sequel/adapters/mysql2'
+require 'sequel/adapters/sqlite'
 require 'sequel/error'
+require 'sequel/sequence/database_ext_connection'
 
 module Sequel
   module Sequence
@@ -12,8 +13,7 @@ module Sequel
 
     module Database
       require 'sequel/sequence/database/postgresql'
-      # require "sequel/sequence/database/mysql"
-      require 'sequel/sequence/database/mysql2'
+      require 'sequel/sequence/database/sqlite'
     end
   end
 end
@@ -24,9 +24,6 @@ Sequel::Database.include(
 Sequel::Postgres::Database.include(
   Sequel::Sequence::Database::PostgreSQL
 )
-Sequel::Mysql2::Database.include(
-  Sequel::Sequence::Database::Mysql2
+Sequel::SQLite::Database.include(
+  Sequel::Sequence::Database::SQLite
 )
-# Sequel::Mysql::Database.include(
-#   Sequel::Sequence::Database::Mysql
-# )

data/sequel-sequence.gemspec

@@ -7,10 +7,11 @@ Gem::Specification.new do |spec|
   spec.version               = Sequel::Sequence::VERSION
   spec.licenses              = ['MIT']
   spec.summary               = \
-    "Add support for PostgreSQL's and MySQL's SEQUENCE on Sequel migrations."
+    '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
-    in Postgresql and Mysql databases within the Sequel ORM.
+    in Postgresql and MariaDB DBMS within the Sequel ORM.
+    It also models the Sequences to meet the needs of SQLite and MySQL users.
   DES
   spec.authors               = ['Nikolai Bocharov']
   spec.email                 = ['it.architect@yahoo.com']
@@ -37,9 +38,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/mariadb_test_helper.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+MariaDB = Sequel.connect(
+  adapter: 'mysql2',
+  user: ENV['TEST_MARIA_USERNAME'] || 'root',
+  password: ENV['TEST_MARIA_PASSWORD'] || 'root',
+  host: ENV['TEST_MARIA_HOST'] || '127.0.0.1',
+  port: ENV['TEST_MARIA_PORT'] || 3306,
+  database: ENV['TEST_MARIA_DATABASE'] || 'test'
+)
+
+module MariadbTestHelper
+  def recreate_table
+    MariaDB.run 'DROP SEQUENCE IF EXISTS position'
+    MariaDB.run 'DROP TABLE IF EXISTS wares'
+    MariaDB.run 'DROP SEQUENCE IF EXISTS a'
+    MariaDB.run 'DROP SEQUENCE IF EXISTS b'
+    MariaDB.run 'DROP SEQUENCE IF EXISTS c'
+    sql = 'CREATE TABLE wares (id INT AUTO_INCREMENT, slug VARCHAR(255), quantity INT DEFAULT(0), PRIMARY KEY(id));'
+    MariaDB.run sql
+  end
+
+  def with_migration(&block)
+    migration_class = Sequel::Migration
+
+    Sequel::Model.db = MariaDB
+
+    Class.new(migration_class, &block).new(MariaDB)
+  end
+end

data/test/mysql_test_helper.rb

@@ -5,20 +5,22 @@ require 'test_helper'
 MysqlDB = Sequel.connect(
   adapter: 'mysql2',
   user: ENV['TEST_MYSQL_USERNAME'] || 'root',
-  password: ENV['TEST_MYSQL_PASSWORD'] || 'root',
-  host: ENV['TEST_MYSQL_HOST'] || '127.0.0.1',
-  port: ENV['TEST_MYSQL_PORT'] || 3306,
+  password: ENV['TEST_MYSQL_PASSWORD'] || 'rootroot',
+  host: ENV['TEST_MYSQL_HOST'] || '0.0.0.0',
+  port: ENV['TEST_MYSQL_PORT'] || 3360,
   database: ENV['TEST_MYSQL_DATABASE'] || 'test'
 )
 
 module MysqlTestHelper
   def recreate_table
-    MysqlDB.run 'DROP SEQUENCE IF EXISTS position'
-    MysqlDB.run 'DROP TABLE IF EXISTS wares'
-    MysqlDB.run 'DROP SEQUENCE IF EXISTS a'
-    MysqlDB.run 'DROP SEQUENCE IF EXISTS b'
-    MysqlDB.run 'DROP SEQUENCE IF EXISTS c'
-    sql = 'CREATE TABLE wares (id INT AUTO_INCREMENT, slug VARCHAR(255), quantity INT DEFAULT(0), PRIMARY KEY(id));'
+    MysqlDB.drop_table :creators, if_exists: true
+    MysqlDB.drop_sequence :position_id, if_exists: true
+    MysqlDB.drop_sequence :position
+    MysqlDB.drop_table :stuffs, if_exists: true
+    MysqlDB.drop_sequence 'a'
+    MysqlDB.drop_sequence 'b'
+    MysqlDB.drop_sequence 'c'
+    sql = 'CREATE TABLE stuffs (id INT AUTO_INCREMENT PRIMARY KEY, slug VARCHAR(255), quantity INT DEFAULT(0));'
     MysqlDB.run sql
   end