sequel-sequence 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7012e03aa326861bef294edcf042850f662f9122664da409aa0dd764d9375d9
-  data.tar.gz: b309b36a931be17ee7cb628c21083ef8543bb60139a249aa9fd1d42378321297
+  metadata.gz: ba4270613514ab8a88b24fa9034314333feba102dff7719a8e238ca1c84e67d1
+  data.tar.gz: 950c6494e0c9f55f6465beee78209649c784508c9c9c0dab1b9817576cbf3a7c
 SHA512:
-  metadata.gz: 7c13a9a6e000990aaee2bdcca4d3d7519a7164c3217d4164f35e40e43deb76f652215169396647568cb03cf111d2a103f2f0f5d5f45e174b8107588e4be1808f
-  data.tar.gz: e9483ab69ea26d780164a4e4683d75c2bd86d8c5d92983b506645c5544a3ebc277f25f12a463b1f959f675f0e780eaf3b22a82b9560e247f16f2a895518d0e53
+  metadata.gz: ed1505fd942d5247ea8ad64b47e1caa9cc420826ace83e4f8c075db257090576772219aa9f48007a0c9d84793f127ec82604a310688717b18ece0ceec8824d66
+  data.tar.gz: c781c917e87029eec161ae656bb331552e6e0f531ceb8c6f3df8b836686f9f1bc7a4f277f81c15a9c515f2861624ed73f978a7be7b7db35d29a32c09aef277f5

data/.github/workflows/ci.yml

@@ -34,16 +34,27 @@ jobs:
           --health-timeout 5s
           --health-retries 5
       mysql:
-        image: mariadb:11.1
+        image: mysql:latest
         env:
-          MARIADB_ROOT_PASSWORD: root
+          MYSQL_ROOT_PASSWORD: rootroot
         ports:
         - 3306:3306
         options: >-
-          --health-cmd="healthcheck.sh --connect --innodb_initialized"
+          --health-cmd="mysqladmin ping"
           --health-interval 10s
           --health-timeout 5s
           --health-retries 3
+      # mariadb:
+      #   image: mariadb:11.1
+      #   env:
+      #     MARIADB_ROOT_PASSWORD: root
+      #   ports:
+      #   - 3306:3306
+      #   options: >-
+      #     --health-cmd="healthcheck.sh --connect --innodb_initialized"
+      #     --health-interval 10s
+      #     --health-timeout 5s
+      #     --health-retries 3
 
     env:
       SEQUEL: ${{ matrix.sequel }}
@@ -54,9 +65,10 @@ jobs:
       - name: Install db dependencies and check connections
         run: |
           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'"
+          mysql --host 127.0.0.1 --port ${{ job.services.mysql.ports[3306] }} -uroot -prootroot -e "SHOW GRANTS FOR 'root'@'localhost'"
           env PGPASSWORD=postgres psql -h localhost -p ${{ job.services.postgres.ports[5432] }} -U postgres -l
           sqlite3 --version
+        # mysql --host 127.0.0.1 --port ${{ job.services.mariadb.ports[3306] }} -uroot -proot -e "SHOW GRANTS FOR 'root'@'localhost'"
 
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
@@ -66,7 +78,11 @@ jobs:
 
       - name: Create MySQL database
         run: |
-          mysql -e 'create database test; use test; create table if not exists wares(id int auto_increment, primary key(id)); create table if not exists builders(id int auto_increment, primary key(id));' --host 127.0.0.1 --port ${{ job.services.mysql.ports[3306] }} -uroot -proot
+          mysql -e 'create database test;' --host 127.0.0.1 --port ${{ job.services.mysql.ports[3306] }} -uroot -prootroot
+
+      # - name: Create MariaDB database
+      #   run: |
+      #     mysql -e 'create database test; use test; create table if not exists wares(id int auto_increment, primary key(id)); create table if not exists builders(id int auto_increment, primary key(id));' --host 127.0.0.1 --port ${{ job.services.mariadb.ports[3306] }} -uroot -proot
 
       - name: Create PostgreSQL database
         env:
@@ -78,19 +94,36 @@ jobs:
         run: |
           mkdir ./db && touch ./db/test.sqlite3 && sqlite3 ./db/test.sqlite3
 
-      - name: Run Tests
-        run: bundle exec rake test
+      # - name: Run MariaDB Tests
+      #   run: bundle exec rake TEST=test/sequel/mariadb_sequence_test.rb
+      #   env:
+      #     TEST_MARIA_DATABASE: test
+      #     TEST_MARIA_HOST: 127.0.0.1
+      #     TEST_MARIA_PORT: ${{ job.services.mariadb.ports[3306] }}
+      #     TEST_MARIA_USERNAME: root
+      #     TEST_MARIA_PASSWORD: root
+
+      - name: Run PostgreSQL Tests
+        run: bundle exec rake TEST=test/sequel/postgresql_sequence_test.rb
         env:
           TEST_POSTGRES_DATABASE: test
           TEST_POSTGRES_HOST: localhost
           TEST_POSTGRES_PORT: ${{ job.services.postgres.ports[5432] }}
           TEST_POSTGRES_USERNAME: postgres
           TEST_POSTGRES_PASSWORD: postgres
+
+      - name: Run MySQL Tests
+        run: bundle exec rake TEST=test/sequel/mysql_sequence_test.rb
+        env:
           TEST_MYSQL_DATABASE: test
           TEST_MYSQL_HOST: 127.0.0.1
           TEST_MYSQL_PORT: ${{ job.services.mysql.ports[3306] }}
           TEST_MYSQL_USERNAME: root
-          TEST_MYSQL_PASSWORD: root
+          TEST_MYSQL_PASSWORD: rootroot
+
+      - name: Run SQLite Tests
+        run: bundle exec rake TEST=test/sequel/sqlite_sequence_test.rb
+        env:
           TEST_SQLITE_DATABASE: "db/test.sqlite3"
 
       - name: Run Rubocop

data/.rubocop.yml

@@ -35,3 +35,6 @@ Style/Documentation:
 Lint/ConstantDefinitionInBlock:
   Exclude:
     - test/**/*
+
+Metrics/ModuleLength:
+  Max: 150

data/CHANGELOG.md

@@ -11,6 +11,13 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v0.4.0 - 2023-09-26
+
+- [Fixed] Differences between MySQL and MariaDB.
+- [Added] Gem API support for MySQL databases.
+- [Changed] README.md, CONTRIBUTING.md and .gemspec description.
+- [Fixed] Some API support for SQLite databases.
+
 ## v0.3.0 - 2023-09-21
 
 - [Added] A parametrized 'IF EXISTS' condition into the drop_sequence.

data/CONTRIBUTING.md

@@ -67,14 +67,21 @@ your contribution is according to how this project works.
 - This project uses [Rubocop](https://rubocop.org) to enforce code style. Before
   submitting your changes, make sure your tests are passing and code conforms to
   the expected style by running `rake`.
+```bash
+$ bundle exec rake rubocop
+```
 - Do not change the library version. This will be done by the maintainer
   whenever a new version is about to be released.
 
-### Ruby tests
+## Ruby tests
+
+Key points in preparing RDBMS and using tests.
+
+### Preparing a PostgreSQL database
 
 - Make sure you have a test PostgreSQL database:
 ```bash
-sudo psql -U USER_NAME -d test
+$ sudo psql -U USER_NAME -d test
 test=# \dt
           List of relations
  Schema |  Name   | Type  |   Owner   
@@ -84,28 +91,31 @@ test=# \dt
 ```
 and role `postgres`
 ```bash
-psql -d test -c 'SELECT rolname FROM pg_roles;'
+$ psql -d test -c 'SELECT rolname FROM pg_roles;'
           rolname          
 ---------------------------
  postgres
 ```
 - If none of them exist, create role
 ```bash
-psql -d postgres -c "create role postgres superuser createdb login password 'postgres';"
+$ psql -d postgres -c "create role postgres superuser createdb login password 'postgres';"
 ```
 and database with a couple of tables:
 
 ```bash
-sudo psql -U postgres -d postgres
+$ sudo psql -U postgres -d postgres
 postgres=# CREATE DATABASE test;
 postgres=# \c test
 test=# CREATE TABLE IF NOT EXISTS things ();
 test=# CREATE TABLE IF NOT EXISTS masters ();
 test=# \q
 ```
-- Make sure you have a test MySQL database:
+
+### Preparing a MariaDB database
+
+- Make sure you have a test MariaDB database:
 ```bash
-mysql
+$ mysql
 MariaDB [(none)]> show databases;
 MariaDB [(none)]> USE test;
 MariaDB [test]> SHOW TABLES;
@@ -123,19 +133,106 @@ 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));
 ```
+
+### Preparing a MySQL database
+
+The optimal way to share Mysql and MariaDB on the same computer is to utilize docker containers.
+
+- Check the local availability of a Mysql container:
+```bash
+$ docker image ls
+REPOSITORY          TAG             IMAGE ID       CREATED         SIZE
+mysql               latest          3503aa5f0751   2 days ago      599MB
+```
+- If there is no distribution package download the docker container with Mysql to the local computer:
+```bash
+$ docker run -p 3360:3306 --name test_mysql  -e MYSQL_ROOT_PASSWORD=rootroot -d mysql:latest
+```
+- Show running containers:
+```bash
+$ docker container ls      
+CONTAINER ID   IMAGE          COMMAND                  CREATED          STATUS          PORTS                               NAMES
+a0d3476699f4   mysql:latest   "docker-entrypoint.s…"   17 minutes ago   Up 11 seconds   33060/tcp, 0.0.0.0:3360->3306/tcp   test_mysql
+```
+- Launch the MySQL container if it is still not running:
+```bash
+$ docker start test_mysql
+```
+
+To create a new database for tests, you could run the MySQL client in the terminal as follows:
+
+- Check the IP address of the running MySQL server:
+```bash
+$ docker inspect test_mysql
+...
+  "IPAddress": "172.17.0.2",
+...
+```
+- Run the MySQL client:
+```bash
+$ docker run -e MYSQL_ROOT_PASSWORD=rootroot -it mysql /bin/bash
+bash-4.4#
+```
+- Launch the MySQL shell:
+```bash
+bash-4.4# mysql -h 172.17.0.2 -u root  -p
+Enter password: 
+Welcome to the MySQL monitor.  Commands end with ; or \g.
+Your MySQL connection id is 8
+Server version: 8.1.0 MySQL Community Server - GPL
+
+Copyright (c) 2000, 2023, Oracle and/or its affiliates.
+
+Oracle is a registered trademark of Oracle Corporation and/or its
+affiliates. Other names may be trademarks of their respective
+owners.
+
+Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.
+
+mysql>
+```
+- Make sure that the test database is available:
+```bash
+mysql> show schemas;
++--------------------+
+| Database           |
++--------------------+
+| information_schema |
+| mysql              |
+| performance_schema |
+| sys                |
+| test               |
++--------------------+
+```
+- If the test danabase doesn't exists, create it:
+```bash
+mysql> CREATE DATABASE test;
+```
+- Create a couple of tables:
+```bash
+mysql> USE test;
+mysql> CREATE TABLE IF NOT EXISTS stuffs(id int auto_increment, primary key(id));
+mysql> CREATE TABLE IF NOT EXISTS creators(id int auto_increment, primary key(id));
+```
+
+### Preparing a SQLite database
+
 - Add a test SQLite database:
 ```bash
-mkdir db && touch db/test.sqlite3
+$ mkdir db && touch db/test.sqlite3
 ```
 - Add a couple of tables in the SQLite database:
 ```bash
-sqlite3 db/test.sqlite3
+$ 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:
+
+### Running tests:
+
 ```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
+$ 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
 ```

data/README.md

@@ -5,7 +5,7 @@
 [![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. Gem includes functionality to cover the needs of SQLite users as well.
+Adds a useful interface for PostgreSQL and MariaDB `SEQUENCE` on Sequel migrations. This Gem includes functionality to meet the needs of MySQL and SQLite users as well.
 
 ## Installation
 
@@ -21,7 +21,7 @@ gem "sequel-sequence"
 
 ## Usage with PostgreSQL and MariaDB
 
-To create a `SEQUENCE`, just use the method `create_sequence`.
+To create and delete a `SEQUENCE`, simply use the `create_sequence` and `drop_sequence` methods.
 
 ```ruby
 Sequel.migration do
@@ -29,6 +29,19 @@ Sequel.migration do
     create_sequence :position, if_exists: false
   end
 
+  down do
+    drop_sequence :position, if_exists: true
+  end
+end
+```
+
+It would also be correct to write:
+```ruby
+Sequel.migration do
+  up do
+    create_sequence :position
+  end
+
   down do
     drop_sequence :position
   end
@@ -39,16 +52,19 @@ You can also specify the initial value and increment:
 
 ```ruby
 create_sequence :position, increment: 2
+create_sequence :position, step: 2
 create_sequence :position, start: 100
 create_sequence :position, if_exists: false
 ```
 
+The `increment` and `step` parameters have the same meaning. By default their values are 1. The default value of `start` is 1 as well.
+
 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, if_exists: false, start: 1
+    create_sequence :position_id, if_exists: false, start: 1000
 
     create_table(:things) do
       primary_key :id
@@ -83,23 +99,26 @@ DB.lastval("position")
 DB.setval("position", 1234)
 ```
 
-## Usage with SQLite
+## Usage with SQLite and MySQL
 
-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`.
+The sequence functionality for SQLite or MySQL databases 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. 
-
+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. 
+```ruby
+create_sequence :position, if_exists: false, start: 1000, numeric_label: 1
+```
+and
 ```ruby
-DB.nextval_with_label("position", 1)
+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.
+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.
 
 ## Maintainer
 

data/Rakefile

@@ -7,7 +7,15 @@ require 'rubocop/rake_task'
 Rake::TestTask.new(:test) do |t|
   t.libs << 'test'
   t.libs << 'lib'
-  t.test_files = FileList['test/**/*_test.rb']
+  t.test_files = FileList['test/sequel/postgresql_sequence_test.rb',
+                          'test/sequel/mariadb_sequence_test.rb',
+                          'test/sequel/sqlite_sequence_test.rb']
+end
+
+Rake::TestTask.new(:mysql) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/mysql_sequence_test.rb']
 end
 
 RuboCop::RakeTask.new

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

@@ -2,6 +2,7 @@
 
 # https://sequel.jeremyevans.net/rdoc/files/doc/sql_rdoc.html
 # https://github.com/jeremyevans/sequel/blob/master/lib/sequel/database/connecting.rb
+# See information about  disable_insert_returning in https://github.com/jeremyevans/sequel/blob/master/doc/release_notes/4.9.0.txt
 module Sequel
   module Sequence
     module Database
@@ -62,7 +63,7 @@ module Sequel
           out
         end
 
-        # for db.database_type = :postgres
+        # for Postgres
         def currval(name)
           name = quote(name.to_s)
           out = nil
@@ -72,7 +73,7 @@ module Sequel
           out
         end
 
-        # for db.database_type = :mysql2
+        # for MariaDB
         alias lastval currval
 
         def setval(name, value)

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Mariadb
+  def quote_column_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 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 << ';'
+
+    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 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
+
+  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 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

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