sequel-sequence 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba4270613514ab8a88b24fa9034314333feba102dff7719a8e238ca1c84e67d1
-  data.tar.gz: 950c6494e0c9f55f6465beee78209649c784508c9c9c0dab1b9817576cbf3a7c
+  metadata.gz: a027c577de1ee27127880328c29208456a26635c9ea18b1c5eb3c1cb0dbbd5fc
+  data.tar.gz: 71764d6ec16bf3425ba3d3bfb4ac47c04dd2a6f7001342c0ae35ebec63af293d
 SHA512:
-  metadata.gz: ed1505fd942d5247ea8ad64b47e1caa9cc420826ace83e4f8c075db257090576772219aa9f48007a0c9d84793f127ec82604a310688717b18ece0ceec8824d66
-  data.tar.gz: c781c917e87029eec161ae656bb331552e6e0f531ceb8c6f3df8b836686f9f1bc7a4f277f81c15a9c515f2861624ed73f978a7be7b7db35d29a32c09aef277f5
+  metadata.gz: 5ce8091d3c644545cecff05c0f85a6252bdd8de015710770a861bfea81793fc50c5b96d19ce304fc2158cd40fc8bfde72f88309e0dc6dea468e2a977a533f980
+  data.tar.gz: a80404a67e51b77a1dd6ac40fe8ebbd93329b170e25855024f325e965f76ec9ad723ea2698fc4f699edad9cd7eb8555c5f6b28d870eb6c2f0355c44686904b19

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
 
@@ -126,5 +125,8 @@ jobs:
         env:
           TEST_SQLITE_DATABASE: "db/test.sqlite3"
 
+      - name: Run Mock Tests
+        run: bundle exec rake TEST=test/sequel/mock_sequence_test.rb
+
       - name: Run Rubocop
         run: bundle exec rake rubocop

data/CHANGELOG.md

@@ -11,6 +11,24 @@ Prefix your message with one of the following:
 - [Security] in case of vulnerabilities.
 -->
 
+## 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.
+- [Added] MySQL tests cover 100%.
+- [Added] SQLite tests cover 100%.
+- [Added] Mock connection to check for additional ORM exceptions.
+
 ## v0.4.0 - 2023-09-26
 
 - [Fixed] Differences between MySQL and MariaDB.

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
 
@@ -235,4 +236,14 @@ $ 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
+$ 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
@@ -24,6 +24,8 @@ gem "sequel-sequence"
 To create and delete a `SEQUENCE`, simply use the `create_sequence` and `drop_sequence` methods.
 
 ```ruby
+require: 'sequel-sequence'
+
 Sequel.migration do
   up do
     create_sequence :position, if_exists: false
@@ -37,6 +39,8 @@ end
 
 It would also be correct to write:
 ```ruby
+require: 'sequel-sequence'
+
 Sequel.migration do
   up do
     create_sequence :position
@@ -48,7 +52,7 @@ Sequel.migration do
 end
 ```
 
-You can also specify the initial value and increment:
+You can also specify the following optional parameters: `if_exists` – a condition of acceptability; `start` – an initial value; `increment` or `step` – step size to the next auto incrementing value:
 
 ```ruby
 create_sequence :position, increment: 2
@@ -95,7 +99,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)
 ```
 
@@ -107,7 +111,7 @@ CREATE TABLE `name_of_your_sequence_table`
 (id integer primary key autoincrement, fiction integer);
 ```
 
-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. 
+You might utilize the last field `fiction` 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
 ```
@@ -120,6 +124,17 @@ By default, `fiction` has a zero value.
 
 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.
+- 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.
+
+## Additional handy functions
+
+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.
+
 ## Maintainer
 
 - [Nikolai Bocharov](https://github.com/oreol-group)

data/Rakefile

@@ -9,7 +9,8 @@ Rake::TestTask.new(:test) do |t|
   t.libs << 'lib'
   t.test_files = FileList['test/sequel/postgresql_sequence_test.rb',
                           'test/sequel/mariadb_sequence_test.rb',
-                          'test/sequel/sqlite_sequence_test.rb']
+                          'test/sequel/sqlite_sequence_test.rb',
+                          'test/sequel/mock_sequence_test.rb']
 end
 
 Rake::TestTask.new(:mysql) do |t|
@@ -18,6 +19,30 @@ Rake::TestTask.new(:mysql) do |t|
   t.test_files = FileList['test/sequel/mysql_sequence_test.rb']
 end
 
+Rake::TestTask.new(:postgresql) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/postgresql_sequence_test.rb']
+end
+
+Rake::TestTask.new(:mariadb) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/mariadb_sequence_test.rb']
+end
+
+Rake::TestTask.new(:sqlite) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/sqlite_sequence_test.rb']
+end
+
+Rake::TestTask.new(:mock) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/sequel/mock_sequence_test.rb']
+end
+
 RuboCop::RakeTask.new
 
 task default: %i[test rubocop]

data/lib/sequel/error.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module Sequel
-  class MethodNotAllowed < StandardError
-    METHOD_NOT_ALLOWED = 'Method not allowed'
+  (
+    # Error raised when attempting to utilize an invalid adapter to SEQUENCE interface.
+    MethodNotAllowed = Class.new(Error)
+  ).name
 
-    # Initialize a new Error object
-    def initialize(message = '')
-      super(message)
-    end
+  class Database
+    METHOD_NOT_ALLOWED = 'Method not allowed'
   end
 end

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

@@ -65,12 +65,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 +95,12 @@ 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
       end
     end

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

@@ -1,71 +1,104 @@
 # frozen_string_literal: true
 
-module Mariadb
-  def quote_column_name(name)
-    "`#{name.gsub('`', '``')}`"
-  end
+module Sequel
+  module Sequence
+    module Database
+      module Server
+        module Mariadb
+          def quote_column_name(name)
+            "`#{name.gsub('`', '``')}`"
+          end
 
-  def quote_sequence_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 custom_sequence?(sequence_name)
+            db = name_of_current_database
+            return false if db.empty?
 
-  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 = "SHOW FULL TABLES WHERE Table_type = 'SEQUENCE' and Tables_in_#{db} = '#{sequence_name}';"
+            fetch(sql).all.size.positive?
+          end
 
-    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 << ';'
+          def check_sequences
+            fetch("SHOW FULL TABLES WHERE Table_type = 'SEQUENCE';").all.to_a
+          end
 
-    run(sql.join("\n"))
-  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)
 
-  def drop_sequence(name)
-    name = quote_name(name.to_s)
-    sql = "DROP SEQUENCE IF EXISTS #{name}"
-    run(sql)
-  end
+            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 << ';'
 
-  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
+            run(sql.join("\n"))
+          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
+          def drop_sequence(name)
+            name = quote_name(name.to_s)
+            sql = "DROP SEQUENCE IF EXISTS #{name}"
+            run(sql)
+          end
 
-  alias currval lastval
+          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 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 lastval(name)
+            quoted_name = quote(name.to_s)
+            out = nil
+            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 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});"
+          def setval(name, value)
+            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
+            value
+          end
+
+          def set_column_default_nextval(table, column, 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
+        end
+      end
+    end
   end
 end