sequel-sequence 0.3.0 → 0.4.1

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+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
+    end
+  end
+end

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

@@ -14,8 +14,11 @@ module Sequel
           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_sqlite_sequence(stringify(name), start_option)
+          sql << insert_into_sequence_table_init_values(stringify(name), start_option, num_label)
           run(sql.join("\n"))
         end
 
@@ -26,12 +29,12 @@ module Sequel
 
         def nextval(name)
           run(insert_into_sequence_table(stringify(name), 0))
-          take_seq(name)
+          take_seq(stringify(name))
         end
 
         def nextval_with_label(name, num_label = 0)
           run(insert_into_sequence_table(stringify(name), num_label))
-          take_seq(name)
+          take_seq(stringify(name))
         end
 
         def lastval(name)
@@ -45,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
@@ -85,25 +84,20 @@ module Sequel
           )
         end
 
-        def insert_into_sequence_table(name, num_label)
-          "INSERT INTO #{name} (fiction) VALUES (#{num_label});"
+        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_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
+        def insert_into_sequence_table(name, num_label)
+          "INSERT INTO #{name} (fiction) VALUES (#{num_label});"
         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)
@@ -119,7 +113,7 @@ module Sequel
             CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} AFTER INSERT
             ON #{table}
             BEGIN
-              INSERT INTO #{sequence}(fiction) VALUES (0);
+              INSERT INTO #{sequence} (fiction) VALUES (0);
               UPDATE #{table}
               SET #{column} = (SELECT MAX(seq) FROM sqlite_sequence WHERE name = '#{sequence}')
               WHERE rowid = NEW.rowid;

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 connection.adapter_name = "PostgreSQL"
+      # for Postgres
       def currval(_name)
-        raise Sequel::MethodNotAllowed, Sequel::MethodNotAllowed::METHOD_NOT_ALLOWED
+        raise Sequel::MethodNotAllowed, Sequel::Database::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
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
       end
 
       def build_exists_condition(option)

data/lib/sequel/sequence/database_ext_connection.rb

@@ -0,0 +1,29 @@
+# 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 = 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
+    end
+  end
+end

data/lib/sequel/sequence/version.rb

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

data/lib/sequel/sequence.rb

@@ -2,10 +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
@@ -13,8 +13,6 @@ 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
@@ -26,12 +24,6 @@ Sequel::Database.include(
 Sequel::Postgres::Database.include(
   Sequel::Sequence::Database::PostgreSQL
 )
-Sequel::Mysql2::Database.include(
-  Sequel::Sequence::Database::Mysql2
-)
-# Sequel::Mysql::Database.include(
-#   Sequel::Sequence::Database::Mysql
-# )
 Sequel::SQLite::Database.include(
   Sequel::Sequence::Database::SQLite
 )

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']

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

@@ -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
 
@@ -29,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/mariadb_sequence_test.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require 'mariadb_test_helper'
+
+class MariadbSequenceTest < Minitest::Test
+  include MariadbTestHelper
+
+  setup do
+    recreate_table
+  end
+
+  test 'adds sequence with default values' do
+    with_migration do
+      def up
+        # create_sequence :position, {start: 1, increment: 1} - default values
+        create_sequence :position
+      end
+    end.up
+
+    assert_equal 1, MariaDB.nextval(:position)
+    assert_equal 2, MariaDB.nextval(:position)
+  end
+
+  test 'adds sequence reader within model and its inherited class' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    class Ware < Sequel::Model; end
+
+    assert_equal 1, Ware.db.nextval('position')
+    assert_equal 2, Ware.db.nextval('position')
+
+    class InheritedWare < Ware; end
+
+    assert_equal 3, InheritedWare.db.nextval(:position)
+    assert_equal 4, InheritedWare.db.nextval(:position)
+  end
+
+  test 'adds sequence starting at 100' do
+    with_migration do
+      def up
+        create_sequence :position, start: 100
+      end
+    end.up
+
+    assert_equal 100, MariaDB.nextval(:position)
+    assert_equal 101, MariaDB.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2' do
+    with_migration do
+      def up
+        create_sequence :position, increment: 2
+      end
+    end.up
+
+    assert_equal 1, MariaDB.nextval(:position)
+    assert_equal 3, MariaDB.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2 (using :step alias)' do
+    with_migration do
+      def up
+        create_sequence :position, step: 2
+      end
+    end.up
+
+    assert_equal 1, MariaDB.nextval(:position)
+    assert_equal 3, MariaDB.nextval(:position)
+  end
+
+  test "returns current/last sequence value, which doesn't increase by itself" do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    MariaDB.nextval(:position)
+
+    assert_equal 1, MariaDB.currval(:position)
+    assert_equal 1, MariaDB.lastval(:position)
+    assert_equal 1, MariaDB.currval(:position)
+    assert_equal 1, MariaDB.lastval(:position)
+  end
+
+  test 'sets sequence value' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    MariaDB.nextval(:position)
+    assert_equal MariaDB.currval(:position), 1
+
+    MariaDB.setval(:position, 101)
+    # in MariaDB, 'lastval' only works after 'nextval' rather than  'setval'
+    assert_equal 1, MariaDB.lastval(:position)
+
+    MariaDB.nextval(:position)
+    # now the value is correct
+    assert_equal 102, MariaDB.lastval(:position)
+  end
+
+  test 'drops sequence and check_sequences' do
+    with_migration do
+      def up
+        create_sequence :position
+      end
+    end.up
+
+    sequence = MariaDB.check_sequences.find_all do |seq|
+      seq[:Tables_in_test] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    with_migration do
+      def down
+        drop_sequence :position
+      end
+    end.down
+
+    sequence = MariaDB.check_sequences.find do |seq|
+      seq[:Tables_in_test] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'orders sequences' do
+    list = MariaDB.check_sequences.map { |s| s[:Tables_in_test] }
+    assert !list.include?('a')
+    assert !list.include?('b')
+    assert !list.include?('c')
+
+    with_migration do
+      def up
+        drop_table :things, if_exists: true
+        create_sequence :c
+        create_sequence :a
+        create_sequence :b
+      end
+    end.up
+
+    list = MariaDB.check_sequences.map { |s| s[:Tables_in_test] }
+    assert list.include?('a')
+    assert list.include?('b')
+    assert list.include?('c')
+  end
+
+  test 'creates table that references sequence' do
+    with_migration do
+      def up
+        drop_table :builders, if_exists: true
+        create_sequence :position_id, if_exists: false, start: 1
+        create_table :builders do
+          primary_key :id
+          String :name, text: true
+          Bignum :position, null: false
+        end
+        set_column_default_nextval :builders, :position, :position_id
+      end
+    end.up
+
+    class Builder < Sequel::Model; end
+
+    builder1 = Builder.create(name: 'Builder 1')
+    pos1 = MariaDB.currval(:position_id)
+    assert_equal pos1, builder1.reload.position
+
+    builder2 = Builder.create(name: 'Builder 2')
+    pos2 = MariaDB.currval(:position_id)
+    assert_equal pos2, builder2.reload.position
+
+    assert_equal pos2 - pos1, 1
+  end
+end