sequel-sequence 0.1.0

data/lib/sequel/sequence/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Sequel
+  module Sequence
+    VERSION = '0.1.0'
+  end
+end

data/lib/sequel/sequence.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'sequel/database'
+require 'sequel/adapters/postgres'
+# require 'sequel/adapters/mysql'
+require 'sequel/adapters/mysql2'
+require 'sequel/error'
+
+module Sequel
+  module Sequence
+    require 'sequel/sequence/database'
+
+    module Database
+      require 'sequel/sequence/database/postgresql'
+      # require "sequel/sequence/database/mysql"
+      require 'sequel/sequence/database/mysql2'
+    end
+  end
+end
+
+Sequel::Database.include(
+  Sequel::Sequence::Database
+)
+Sequel::Postgres::Database.include(
+  Sequel::Sequence::Database::PostgreSQL
+)
+Sequel::Mysql2::Database.include(
+  Sequel::Sequence::Database::Mysql2
+)
+# Sequel::Mysql::Database.include(
+#   Sequel::Sequence::Database::Mysql
+# )

data/lib/sequel-sequence.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'sequel/sequence'

data/sequel-sequence.gemspec

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require './lib/sequel/sequence/version'
+
+Gem::Specification.new do |spec|
+  spec.name                  = 'sequel-sequence'
+  spec.version               = Sequel::Sequence::VERSION
+  spec.licenses              = ['MIT']
+  spec.summary               = \
+    "Add support for PostgreSQL's and MySQL's SEQUENCE on Sequel migrations."
+  spec.description           = <<-DES
+    This gem provides a single interface for SEQUENCE functionality
+    in Postgresql and Mysql databases within the Sequel ORM.
+  DES
+  spec.authors               = ['Nikolai Bocharov']
+  spec.email                 = ['it.architect@yahoo.com']
+  spec.files                 = `git ls-files -z`.split("\x0")
+  spec.require_paths         = ['lib']
+  spec.extra_rdoc_files      = ['README.md']
+  spec.homepage              = 'https://rubygems.org/gems/sequel-sequence'
+  spec.metadata              = {
+    'source_code_uri' => 'https://github.com/oreol-group/sequel-sequence',
+    'changelog_uri' => 'https://github.com/oreol-group/sequel-sequence/blob/master/CHANGELOG.md',
+    'bug_tracker_uri' => 'https://github.com/oreol-group/sequel-sequence/issues'
+  }
+  spec.platform              = Gem::Platform::RUBY
+  spec.required_ruby_version = '>= 2.7.0'
+
+  spec.add_dependency 'sequel'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest-utils'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'simplecov'
+  if RUBY_ENGINE == 'jruby'
+    # JRuby Adapter Dependencies
+    spec.add_development_dependency 'jdbc-mysql'
+    spec.add_development_dependency 'jdbc-postgres'
+  else
+    # MRI/Rubinius Adapter Dependencies
+    spec.add_development_dependency 'mysql2'
+    spec.add_development_dependency 'pg'
+  end
+end

data/test/mysql_test_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+MysqlDB = Sequel.connect('mysql2://root:root@localhost/test')
+
+Sequel::Model.db = MysqlDB
+
+class Ware < Sequel::Model
+end
+
+class InheritedWare < Ware
+end
+
+class Builder < Sequel::Model
+end
+
+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.run sql
+  end
+end

data/test/postgresql_test_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+PostgresqlDB = Sequel.connect('postgres:///test')
+
+Sequel::Model.db = PostgresqlDB
+
+class Thing < Sequel::Model
+end
+
+class InheritedThing < Thing
+end
+
+class Master < Sequel::Model
+end
+
+module PostgresqlTestHelper
+  def recreate_table
+    PostgresqlDB.run 'DROP TABLE IF EXISTS things'
+    PostgresqlDB.run 'DROP SEQUENCE IF EXISTS position'
+    PostgresqlDB.run 'DROP SEQUENCE IF EXISTS a'
+    PostgresqlDB.run 'DROP SEQUENCE IF EXISTS b'
+    PostgresqlDB.run 'DROP SEQUENCE IF EXISTS c'
+    sql = 'CREATE TABLE things (id SERIAL PRIMARY KEY, slug VARCHAR(255), quantity INTEGER DEFAULT 0);'
+    PostgresqlDB.run sql
+  end
+end

data/test/sequel/mysql_sequence_test.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+require 'mysql_test_helper'
+
+class MysqlSequenceTest < Minitest::Test
+  include MysqlTestHelper
+
+  setup do
+    recreate_table
+  end
+
+  test 'adds sequence with default values' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(MysqlDB, :up)
+
+    assert_equal 1, Ware.db.nextval(:position)
+    assert_equal 2, Ware.db.nextval(:position)
+  end
+
+  test 'adds sequence reader within inherited class' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(MysqlDB, :up)
+
+    assert_equal 1, InheritedWare.db.nextval(:position)
+    assert_equal 2, InheritedWare.db.nextval(:position)
+  end
+
+  test 'adds sequence starting at 100' do
+    Sequel.migration do
+      up do
+        create_sequence :position, start: 100
+      end
+    end.apply(MysqlDB, :up)
+
+    assert_equal 100, Ware.db.nextval(:position)
+    assert_equal 101, Ware.db.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2' do
+    Sequel.migration do
+      up do
+        create_sequence :position, increment: 2
+      end
+    end.apply(MysqlDB, :up)
+
+    assert_equal 1, Ware.db.nextval(:position)
+    assert_equal 3, Ware.db.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2 (using :step alias)' do
+    Sequel.migration do
+      up do
+        create_sequence :position, step: 2
+      end
+    end.apply(MysqlDB, :up)
+
+    assert_equal 1, Ware.db.nextval(:position)
+    assert_equal 3, Ware.db.nextval(:position)
+  end
+
+  test 'returns current/last sequence value without incrementing it' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(MysqlDB, :up)
+
+    Ware.db.nextval(:position)
+
+    assert_equal 1, Ware.db.currval(:position)
+    assert_equal 1, Ware.db.lastval(:position)
+    assert_equal 1, Ware.db.currval(:position)
+    assert_equal 1, Ware.db.lastval(:position)
+  end
+
+  test 'sets sequence value' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(MysqlDB, :up)
+
+    Ware.db.nextval(:position)
+    assert_equal Ware.db.currval(:position), 1
+
+    # in mariaDB, 'lastval' only works after 'nextval' rather than  'setval'
+    Ware.db.setval(:position, 101)
+    Ware.db.nextval(:position)
+    assert_equal Ware.db.lastval(:position), 102
+  end
+
+  test 'drops sequence and check_sequences' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(MysqlDB, :up)
+
+    sequence = MysqlDB.check_sequences.find_all do |seq|
+      seq[:Tables_in_test] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    Sequel.migration do
+      down do
+        drop_sequence :position
+      end
+    end.apply(MysqlDB, :down)
+
+    sequence = MysqlDB.check_sequences.find do |seq|
+      seq[:sequence_name] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'orders sequences' do
+    list = MysqlDB.check_sequences.map { |s| s[:Tables_in_test] }
+    assert !list.include?('a')
+    assert !list.include?('b')
+    assert !list.include?('c')
+
+    Sequel.migration do
+      up do
+        drop_table :things, if_exists: true
+        # drop_table :masters, if_exists: true
+        create_sequence :c
+        create_sequence :a
+        create_sequence :b
+      end
+    end.apply(MysqlDB, :up)
+
+    list = MysqlDB.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
+    Sequel.migration do
+      up do
+        drop_table :builders, if_exists: true
+        create_sequence :position_id, if_exists: false
+        create_table :builders do
+          primary_key :id
+          String :name, text: true
+
+          # PostgreSQL uses bigint as the sequence's default type.
+          Bignum :position, null: false
+        end
+        set_column_default_nextval :builders, :position, :position_id
+      end
+    end.apply(MysqlDB, :up)
+
+    builder1 = Builder.create(name: 'Builder 1')
+    pos1 = MysqlDB.currval(:position_id)
+    assert_equal pos1, builder1.reload.position
+
+    builder2 = Builder.create(name: 'Builder 2')
+    pos2 = MysqlDB.currval(:position_id)
+    assert_equal pos2, builder2.reload.position
+
+    assert_equal pos2 - pos1, 1
+  end
+end

data/test/sequel/postgresql_sequence_test.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require 'postgresql_test_helper'
+
+class PostgresqlSequenceTest < Minitest::Test
+  include PostgresqlTestHelper
+
+  setup do
+    recreate_table
+  end
+
+  test 'adds sequence with default values' do
+    Sequel.migration do
+      up do
+        # create_sequence :position, {start: 1, increment: 1} - default values
+        create_sequence :position
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal 1, PostgresqlDB.nextval('position')
+    assert_equal 2, PostgresqlDB.nextval('position')
+  end
+
+  test 'adds sequence reader within inherited class' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal 1, InheritedThing.db.nextval(:position)
+    assert_equal 2, InheritedThing.db.nextval(:position)
+  end
+
+  test 'adds sequence starting at 100' do
+    Sequel.migration do
+      up do
+        create_sequence :position, start: 100
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal 100, Thing.db.nextval(:position)
+    assert_equal 101, Thing.db.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2' do
+    Sequel.migration do
+      up do
+        create_sequence :position, increment: 2
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal 1, Thing.db.nextval(:position)
+    assert_equal 3, Thing.db.nextval(:position)
+  end
+
+  test 'adds sequence incremented by 2 (using :step alias)' do
+    Sequel.migration do
+      up do
+        create_sequence :position, step: 2
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal 1, Thing.db.nextval(:position)
+    assert_equal 3, Thing.db.nextval(:position)
+  end
+
+  test 'returns current (or last as alias) sequence value without incrementing it' do
+    Sequel.migration do
+      up do
+        create_sequence :position, start: 2, increment: 2
+      end
+    end.apply(PostgresqlDB, :up)
+
+    Thing.db.nextval(:position)
+
+    assert_equal 2, Thing.db.currval(:position)
+    assert_equal 2, Thing.db.lastval(:position)
+    assert_equal 2, Thing.db.currval(:position)
+    assert_equal 2, Thing.db.lastval(:position)
+  end
+
+  test 'sets sequence value' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(PostgresqlDB, :up)
+
+    Thing.db.nextval(:position)
+    assert_equal Thing.db.currval(:position), 1
+
+    Thing.db.setval(:position, 101)
+    assert_equal 101, Thing.db.currval(:position)
+  end
+
+  test 'drops sequence and check_sequences' do
+    Sequel.migration do
+      up do
+        create_sequence :position
+      end
+    end.apply(PostgresqlDB, :up)
+
+    sequence = PostgresqlDB.check_sequences.find_all do |seq|
+      seq[:sequence_name] == 'position'
+    end
+
+    assert_equal 1, sequence.size
+
+    Sequel.migration do
+      down do
+        drop_sequence :position
+      end
+    end.apply(PostgresqlDB, :down)
+
+    sequence = PostgresqlDB.check_sequences.find do |seq|
+      seq[:sequence_name] == 'position'
+    end
+
+    assert_nil sequence
+  end
+
+  test 'orders sequences' do
+    list = PostgresqlDB.check_sequences.map { |s| s[:sequence_name] }
+    assert !list.include?('a')
+    assert !list.include?('b')
+    assert !list.include?('c')
+
+    Sequel.migration do
+      up do
+        drop_table :things, if_exists: true
+        # drop_table :masters, if_exists: true
+        create_sequence :c
+        create_sequence :a
+        create_sequence :b
+      end
+    end.apply(PostgresqlDB, :up)
+
+    list = PostgresqlDB.check_sequences.map { |s| s[:sequence_name] }
+    assert list.include?('a')
+    assert list.include?('b')
+    assert list.include?('c')
+  end
+
+  test 'checks custom sequence generated from code' do
+    assert_equal PostgresqlDB.custom_sequence?(:c), false
+
+    Sequel.migration do
+      up do
+        create_sequence :c
+      end
+    end.apply(PostgresqlDB, :up)
+
+    assert_equal PostgresqlDB.custom_sequence?(:c), true
+  end
+
+  test 'creates table that references sequence' do
+    Sequel.migration do
+      up do
+        drop_table :masters, if_exists: true
+        create_sequence :position_id, if_exists: false
+        create_table :masters do
+          primary_key :id
+          String :name, text: true
+
+          # PostgreSQL uses bigint as the sequence's default type.
+          Bignum :position, null: false
+        end
+        set_column_default_nextval :masters, :position, :position_id
+      end
+    end.apply(PostgresqlDB, :up)
+
+    master1 = Master.create(name: 'MASTER 1')
+    pos1 = PostgresqlDB.currval(:position_id)
+    assert_equal pos1, master1.reload.position
+
+    master2 = Master.create(name: 'MASTER 2')
+    pos2 = PostgresqlDB.currval(:position_id)
+    assert_equal pos2, master2.reload.position
+
+    assert_equal pos2 - pos1, 1
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+SimpleCov.start
+
+require 'bundler/setup'
+require 'sequel'
+require 'sequel/extensions/migration'
+require 'sequel/sequence'
+require 'minitest/utils'
+require 'minitest/autorun'