sequel-sequence 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 749ea113ce41f1f7f70f620d5aa70deac470a76491cdb36b4bd8e5c739487a07
-  data.tar.gz: 9628bc8f57ad5a1ead78d82eaa8348963876c93a6be40df0d8c9dabfab928f76
+  metadata.gz: e6e1a94456ed2dca944d9f5dc7775acdde3db19912cf65c556fc315902dd6514
+  data.tar.gz: 0c6c8ec72019f94c819922dc3c8cc63e63e0d0138a3f95ed442384838d02beb5
 SHA512:
-  metadata.gz: d0dbf107132dad0bcd23bcf5da23cb9fb121119dafb109865978a6bf26fe8465985875fd6d33b72422cd57e1d5b74b54fce065ba7a2fdf21b0d76f032b7c149e
-  data.tar.gz: bd1bbeaf56ddcd37b4bc86b6b83ad06e85212c7f09bb32db03004bfc9599dd240b141ea6c6130d64fe8b85471c3e6bb7cd8537714b7b6f34f744142b117ce606
+  metadata.gz: 97954c433db834abdd23e91fd97abfee863f7f55bcf08d83048a6f3afd7d8fa9e780bfab010758af8b0ec01936ff1f40461ff5ec942e39bf59da894b23670798
+  data.tar.gz: 208dc0051f42068cae2009bb2ee04b0cfc1f0381aa872504621541d3ea36d8aef7aa8800559425a5c107eac8620d82f52722444d8bda0de58caf20e9ced1145f

data/.ci.gemfile

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'bundler', '>= 2.2.4'
+gem 'minitest-utils', '~> 0.4.6'
+gem 'pry-byebug', '~> 3.10.1'
+gem 'rake', '~> 13.0.2'
+gem 'rubocop', '~> 1.56.3'
+gem 'sequel', '>= 5.28', '<6.0'
+gem 'simplecov', '~> 0.22.0'
+
+# MRI/Rubinius Adapter Dependencies
+platform :ruby do
+  gem 'mysql2', '~> 0.5.3'
+  gem 'pg', '~> 1.5.4'
+  gem 'sqlite3', '~> 1.6.0'
+end
+
+# JRuby Adapter Dependencies
+platform :jruby do
+  gem 'jdbc-mysql', '~> 8.0.17'
+  gem 'jdbc-postgres', '~> 42.2.14'
+  gem 'jdbc-sqlite3', '~> 3.42'
+end

data/.github/workflows/ci.yml

@@ -16,7 +16,6 @@ jobs:
         os: ['ubuntu-latest']
         sequel: ['~>5.28']
         ruby: ['3.2', '3.1', '3.0', '2.7']
-        gemfile: ['Gemfile']
     runs-on: ${{ matrix.os }}
     name: Tests with Ruby ${{ matrix.ruby }}
 
@@ -58,7 +57,7 @@ jobs:
 
     env:
       SEQUEL: ${{ matrix.sequel }}
-      BUNDLE_GEMFILE: ${{ matrix.gemfile }}
+      BUNDLE_GEMFILE: .ci.gemfile
     steps:
       - uses: actions/checkout@v4
 

data/CHANGELOG.md

@@ -11,6 +11,27 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## v0.5.0 - 2023-10-08
+
+- [Fixed] The conditions of migrations were clarified and fixed in README.md.
+- [Added] The `delete_to_currval(name)` method for MySQL and SQLite `SEQUENCE`-table and Exceptions for any other cases.
+- [Added] The `drop_sequence?` can accept multiple arguments with condition 'IF EXISTS'.
+- [Added] The `create_sequence!` drops the `SEQUENCE` if it exists before attempting to create it.
+- [Changed] INT type to BIGINT type for the primery key of a MySQL `SEQUENCE`-table.
+- [Added] The ext. params for the PostgreSql `SEQUENCE` ( https://www.postgresql.org/docs/current/sql-createsequence.html )
+- [Added] The ext. params for the Mariadb `SEQUENCE` ( https://mariadb.com/kb/en/create-sequence )
+
+## v0.4.2 - 2023-10-03
+
+- [Added] Additions into README.md.
+- [Added] Exclusion of dependence on the Postgresql constraint for "PG::The object is not in the required state P: ERROR:  currval of sequence "name_of_sequence" is not yet defined in this session".
+- [Added] `custom_sequence?` method for MariaDB and SQLite.
+- [Fixed] Dependencies on gems by moving them from .gemspec to Gemfile
+- [Fixed] `currval` for initial state of sequence in Postgresql
+- [Fixed] `lastval` for initial state of sequence in MariaDB
+- [Changed] The default action `setval` for MariaDB to invoke `setval` if necessary
+- [Changed] The class initialization algorithm in `sequence.rb` depending on the gems included in the user project.
+
 ## v0.4.1 - 2023-09-28
 
 - [Added] Important notice to README.md.

data/CONTRIBUTING.md

@@ -33,13 +33,14 @@ your contribution is according to how this project works.
 
 1. [Fork](https://help.github.com/forking/) sequel-sequence
 2. Create a topic branch - `git checkout -b my_branch`
-3. Make your changes using [descriptive commit messages](#commit-messages)
-4. Update CHANGELOG.md describing your changes by adding an entry to the
+3. Unlock gem dependencies in `sequel-sequence.gemspec`
+4. Make your changes using [descriptive commit messages](#commit-messages)
+5. Update CHANGELOG.md describing your changes by adding an entry to the
    "Unreleased" section. If this section is not available, create one right
    before the last version.
-5. Push to your branch - `git push origin my_branch`
-6. [Create a pull request](https://docs.github.com/articles/creating-a-pull-request)
-7. That's it!
+6. Push to your branch - `git push origin my_branch`
+7. [Create a pull request](https://docs.github.com/articles/creating-a-pull-request)
+8. That's it!
 
 ## Styleguides
 
@@ -237,3 +238,12 @@ $ 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/mock_sequence_test.rb
 ```
+
+Short command:
+```bash
+$ bundle exec rake postgresql
+$ bundle exec rake mariadb
+$ bundle exec rake mysql
+$ bundle exec rake sqlite
+$ bundle exec rake mock
+```

data/README.md

@@ -16,7 +16,7 @@ gem install sequel-sequence
 Or add the following line to your project's Gemfile:
 
 ```ruby
-gem "sequel-sequence"
+gem 'sequel-sequence'
 ```
 
 ## Usage with PostgreSQL and MariaDB
@@ -82,6 +82,17 @@ Sequel.migration do
 end
 ```
 
+Before running the migration for your application, don't forget to invoke `require`s, for example like this:
+```ruby
+require 'sequel'
+require 'sequel-sequence'
+
+migrate = -> (env, version) do
+  ...
+  Sequel::Migrator.apply(DB, 'db/migrations', version)
+end
+```
+
 This gem also adds a few helpers to interact with `SEQUENCE`s.
 
 ```ruby
@@ -95,7 +106,7 @@ DB.currval("position")
 DB.lastval("position")
 # Both options are acceptable in PostgreSQL and MySQL.
 
-# Set sequence's current value. It must be greater than lastval or currval.
+# Set a new sequence value. It must be greater than lastval or currval. Only PostgreSQL allows setting a lower value.
 DB.setval("position", 1234)
 ```
 
@@ -116,13 +127,39 @@ and
 DB.nextval_with_label(:position, 1)
 ```
 
-By default, `fiction` has a zero value.
+By default, `fiction` has a zero value. Moreover, it is assumed that you can use the history of sequence changes, for example, to collect statistics on the fiction field. However, in most cases, such statistics will not be necessary and you can program periodic cleaning of the SEQUENCE table using the method:
+```ruby
+DB.delete_to_currval(:position)
+```
 
 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.
 
 ## Known issues you may encounter
 
-This solution does not allow you to simultaneously work with MySQL and MariaDB databases from one application. If such a need arises, move the data processing functionality to different microservices.
+- This solution does not allow you to simultaneously work with MySQL and MariaDB databases from one application. If such a need arises, move the data processing functionality to different microservices.
+- When you start with a new database in SQLite, you'll receive an error message - "`SQLite3::SQLException: no such table: sqlite_sequence`".  `sqlite_sequence` table is not created, until you define at least one autoincrement and primary key column in your schema.
+
+All methods defined in this gem can use either a String or a Symbol parameter to denote a `SEQUENCE`. 
+```ruby
+DB.nextval('position')
+```
+is equivalent to
+```ruby
+DB.nextval(:position)
+```
+- This solution allows you to specify advanced options for a `SEQUENCE` when creating it in PostgreSQL and MariaDB. For more information, check out the description at https://www.postgresql.org/docs/current/sql-createsequence.html and https://mariadb.com/kb/en/create-sequence.
+
+## Additional handy methods:
+
+To discover a database information about `SEQUENCE`s you could take advantage of `check_sequences` and `custom_sequence?` methods.
+- `custom_sequence?(:sequence_name)` allows you to instantly find out the availability of the called `SEQUENCE`. 
+- `check_sequences` provides complete information about known `SEQUENCE`s in the datebase. The output data depends on RDBMS.
+
+To remove several sequences at once, you can use the method:
+- `drop_sequence?` can accept multiple arguments of `SEQUENCE`s and checks the `IF EXISTS` condition for each one.
+
+To drop previous `SEQUENCE` and recreate the new one utilize the method:
+- `create_sequence!`.
 
 ## Maintainer
 

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

@@ -7,8 +7,6 @@ module Sequel
   module Sequence
     module Database
       module PostgreSQL
-        SEQUENCE_COMMENT = 'created by sequel-sequence'
-
         def quote_column_name(name)
           PG::Connection.quote_ident(name).freeze
         end
@@ -27,7 +25,7 @@ module Sequel
             return false
           end
 
-          out == SEQUENCE_COMMENT
+          out == Sequel::Database::SEQUENCE_COMMENT
         end
 
         def check_sequences
@@ -35,23 +33,37 @@ module Sequel
         end
 
         def create_sequence(name, options = {})
+          data_type = options[:data_type]
+          minvalue = options[:minvalue]
+          maxvalue = options[:maxvalue]
+          start = options[:start]
+          cache = options[:cache]
+          cycle = options[:cycle]
+          owned_by = options[:owned_by]
+
           increment = options[:increment] || options[:step]
           if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
 
           sql = ["CREATE SEQUENCE #{if_exists} #{name}"]
+          sql << "AS #{data_type}" if data_type
           sql << "INCREMENT BY #{increment}" if increment
-          sql << "START WITH #{options[:start]}" if options[:start]
+          sql << "MINVALUE  #{minvalue}" if minvalue
+          sql << "MAXVALUE  #{maxvalue}" if maxvalue
+          sql << "START WITH #{start}" if start
+          sql << "CACHE  #{cache}" if cache
+          sql << cycle.to_s if cycle
+          sql << "OWNED BY  #{owned_by}" if owned_by
           sql << ';'
-          sql << "COMMENT ON SEQUENCE #{name} IS '#{SEQUENCE_COMMENT}';"
+          sql << "COMMENT ON SEQUENCE #{name} IS '#{Sequel::Database::SEQUENCE_COMMENT}';"
 
           run(sql.join("\n"))
         end
 
-        def drop_sequence(name)
+        def drop_sequence(name, options = {})
+          if_exists = build_exists_condition(options[:if_exists])
           name = quote_name(name.to_s)
-          sql = "DROP SEQUENCE IF EXISTS #{name}"
-          run(sql)
+          run drop_sequence_table(name, if_exists)
         end
 
         def nextval(name)
@@ -65,12 +77,21 @@ module Sequel
 
         # for Postgres
         def currval(name)
-          name = quote(name.to_s)
+          quoted_name = quote(name.to_s)
           out = nil
-          fetch("SELECT currval(#{name})") do |row|
+          fetch("SELECT currval(#{quoted_name})") do |row|
             out = row[:currval]
           end
           out
+        rescue Sequel::DatabaseError => e
+          # We exclude dependence on the postgresql constraint.
+          if e.message =~ /\APG::ObjectNotInPrerequisiteState:(.)*is not yet defined in this session\n\z/
+            return nextval(name)
+          end
+
+          # :nocov:
+          raise e
+          # :nocov:
         end
 
         # for MariaDB
@@ -86,11 +107,18 @@ module Sequel
         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}::regclass)"
+          sql = %(
+            ALTER TABLE IF EXISTS #{table}
+            ALTER COLUMN #{quote_name(column.to_s)}
+            SET DEFAULT nextval(#{quote(sequence.to_s)}::regclass)
+          ).strip
+          run sql
+        end
+
+        private
+
+        def drop_sequence_table(name, if_exists = nil)
+          "DROP SEQUENCE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
         end
       end
     end

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

@@ -13,27 +13,46 @@ module Sequel
             "`#{name.gsub(/[`"']/, '')}`"
           end
 
+          def custom_sequence?(sequence_name)
+            db = name_of_current_database
+            return false if db.empty?
+
+            sql = "SHOW FULL TABLES WHERE Table_type = 'SEQUENCE' and Tables_in_#{db} = '#{sequence_name}';"
+            fetch(sql).all.size.positive?
+          end
+
           def check_sequences
             fetch("SHOW FULL TABLES WHERE Table_type = 'SEQUENCE';").all.to_a
           end
 
           def create_sequence(name, options = {})
+            minvalue = options[:minvalue]
+            maxvalue = options[:maxvalue]
+            start = options[:start]
+            cache = options[:cache]
+            cycle = options[:cycle]
+
             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 << "MINVALUE  #{minvalue}" if minvalue
+            sql << "MAXVALUE  #{maxvalue}" if maxvalue
+            sql << "START WITH #{start}" if start
+            sql << "CACHE  #{cache}" if cache
+            sql << cycle.to_s if cycle
+            sql << "COMMENT '#{Sequel::Database::SEQUENCE_COMMENT}'"
             sql << ';'
 
             run(sql.join("\n"))
           end
 
-          def drop_sequence(name)
+          def drop_sequence(name, options = {})
+            if_exists = build_exists_condition(options[:if_exists])
             name = quote_name(name.to_s)
-            sql = "DROP SEQUENCE IF EXISTS #{name}"
-            run(sql)
+            run drop_sequence_table(name, if_exists)
           end
 
           def nextval(name)
@@ -46,31 +65,52 @@ module Sequel
           end
 
           def lastval(name)
-            name = quote(name.to_s)
+            quoted_name = quote(name.to_s)
             out = nil
-            fetch("SELECT lastval(#{name});") do |row|
-              out = row["lastval(#{name})".to_sym]
+            fetch("SELECT lastval(#{quoted_name});") do |row|
+              out = row["lastval(#{quoted_name})".to_sym]
             end
+            return nextval(name) if out.nil?
+
             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]
+            current = lastval(name)
+            if value <= current
+              log_info Sequel::Database::DANGER_OPT_ID if value < current
+              value = current
+            else
+              quoted_name = quote(name.to_s)
+              value -= 1
+              out = nil
+              fetch("SELECT setval(#{quoted_name}, #{value});") do |row|
+                out = row["setval(#{quoted_name}, #{value})".to_sym]
+              end
+              value = nextval(name)
             end
-            out
+            value
           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});"
+            sql = %(
+              ALTER TABLE IF EXISTS #{quote(table.to_s)}
+              ALTER COLUMN #{quote_name(column.to_s)}
+              SET DEFAULT nextval(#{quote(sequence.to_s)})
+            ).strip
+            run sql
+          end
+
+          private
+
+          def name_of_current_database
+            fetch('SELECT DATABASE() AS db;').first[:db]
+          end
+
+          def drop_sequence_table(name, if_exists = nil)
+            "DROP SEQUENCE #{if_exists || Sequel::Database::IF_EXISTS} #{name};"
           end
         end
       end

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

@@ -60,7 +60,7 @@ 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
@@ -75,12 +75,16 @@ module Sequel
           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))
+            run trigger_create_sequenced_column(stringify(table),
+                                                stringify(column),
+                                                stringify(sequence))
+            run trigger_update_sequenced_column(stringify(table),
+                                                stringify(column),
+                                                stringify(sequence))
+          end
+
+          def delete_to_currval(name)
+            run delete_to_current_seq(stringify(name))
           end
 
           private
@@ -97,8 +101,8 @@ module Sequel
           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);
+              (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY,
+               fiction BIGINT);
             ).strip
           end
 
@@ -109,7 +113,7 @@ module Sequel
           def create_mysql_sequence
             %(
               CREATE TABLE #{Sequel::Database::IF_NOT_EXISTS} mysql_sequence
-              (name VARCHAR(40), seq INT);
+              (name VARCHAR(40), seq BIGINT);
             ).strip
           end
 
@@ -147,7 +151,7 @@ module Sequel
             "INSERT INTO mysql_sequence (name, seq) VALUES ('#{name}', LAST_INSERT_ID());"
           end
 
-          def create_sequenced_column(table, _column, sequence)
+          def trigger_create_sequenced_column(table, _column, sequence)
             %(
               CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} BEFORE INSERT
               ON #{table}
@@ -160,7 +164,7 @@ module Sequel
             ).strip
           end
 
-          def update_sequenced_column(table, column, sequence)
+          def trigger_update_sequenced_column(table, column, sequence)
             %(
               CREATE TRIGGER IF NOT EXISTS #{table}_#{column} BEFORE INSERT
               ON #{table}
@@ -178,6 +182,10 @@ module Sequel
             raise e
             # :nocov:
           end
+
+          def delete_to_current_seq(name)
+            "DELETE QUICK IGNORE FROM #{name} WHERE id < (SELECT * FROM (SELECT MAX(id) FROM #{name} ) AS a);"
+          end
         end
       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,11 +49,11 @@ 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
-            log_info DANGER_OPT_ID
+            log_info Sequel::Database::DANGER_OPT_ID
             value = current
           else
             run(update_sqlite_sequence(stringify(name), value))
@@ -57,9 +62,13 @@ module Sequel
         end
 
         def set_column_default_nextval(table, column, sequence)
-          run(create_sequenced_column(stringify(table),
-                                      stringify(column),
-                                      stringify(sequence)))
+          run(trigger_create_sequenced_column(stringify(table),
+                                              stringify(column),
+                                              stringify(sequence)))
+        end
+
+        def delete_to_currval(name)
+          run delete_to_current_seq(stringify(name))
         end
 
         private
@@ -79,7 +88,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
@@ -101,14 +110,14 @@ module Sequel
         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)
           "SELECT MAX(seq) AS id FROM sqlite_sequence WHERE name = '#{name}';"
         end
 
-        def create_sequenced_column(table, column, sequence)
+        def trigger_create_sequenced_column(table, column, sequence)
           %(
             CREATE TRIGGER IF NOT EXISTS #{table}_#{sequence} AFTER INSERT
             ON #{table}
@@ -120,6 +129,10 @@ module Sequel
             END;
           )
         end
+
+        def delete_to_current_seq(name)
+          "DELETE FROM #{name} WHERE id < (SELECT MAX(id) FROM #{name});"
+        end
       end
     end
   end

data/lib/sequel/sequence/database.rb

@@ -7,6 +7,7 @@ module Sequel
       DANGER_OPT_INCREMENT = 'Warning! Increments greater than 1 are not supported.'
       IF_EXISTS = 'IF EXISTS'
       IF_NOT_EXISTS = 'IF NOT EXISTS'
+      SEQUENCE_COMMENT = 'created by sequel-sequence'
 
       def check_options(params)
         log_info DANGER_OPT_INCREMENT if params[:increment] && params[:increment] != 1
@@ -73,6 +74,22 @@ module Sequel
           IF_NOT_EXISTS
         end
       end
+
+      def delete_to_currval(_name)
+        raise Sequel::MethodNotAllowed, Sequel::Database::METHOD_NOT_ALLOWED
+      end
+
+      def drop_sequence?(*names)
+        names.each do |n|
+          drop_sequence(n, if_exists: true)
+        end
+        false
+      end
+
+      def create_sequence!(name, options = nil)
+        drop_sequence(name, if_exists: true)
+        create_sequence(name, options)
+      end
     end
   end
 end

data/lib/sequel/sequence/version.rb

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