postgresql_adapter_extensions 0.1.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25ccea630bf61806d88d841a44cc2a93a62c913ebf994372688d0ffc7375e438
-  data.tar.gz: bd8f330b22a661a2e87d1e504612d9fc62e6bffc937c309e11dcf084e59542a9
+  metadata.gz: db065d0487684a0647e17b2db8e5ef1f2131a6b15a7b0316d1fcd9856e46c07a
+  data.tar.gz: bd6cb683c11d9e27c1225d5c29e638adf6f14b96b1f7c3bf1803d96944383478
 SHA512:
-  metadata.gz: 778b4da5621103a713d6c2d1916a77cdd0a1e3014acba25cc86b7d94c21dec91de1326a487681074a8f94a8c591ad5c4f303db9993169a7f42c3650a98109202
-  data.tar.gz: 594610e027b650079a839b7df925ef8e2bc0baa4ad4892d46424ed745c5be3e634df0bee55652d714bd55eca5ac7efba428a8bee92eb467c3149945e8715d2c4
+  metadata.gz: 986daa750a1e762d710dbda29ba587ea8c76a8894f2c7ff346b2d64dc974e4c3fe54098e9549646d584c8b8c9efb5ebe00e0581a3d00c76dc3be253e7d5af9c5
+  data.tar.gz: 8dc3a0571ff79ce9dd058ab3c22e0876c07cd748ddc0b4c42b5f642e51869aaddc353b144be5f1feff165cbe967bacaf08f0e70dbe0828fba8ffe8fa5703c5fc

data/.github/workflows/docs.yml

@@ -0,0 +1,31 @@
+name: Publish Documentation to GitHub Pages
+on:
+  push:
+    branches:
+      - main
+jobs:
+  build:
+    name: Publish Documentation to GitHub Pages ${{ matrix.ruby }}
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    strategy:
+      matrix:
+        ruby:
+          - "3.3.7"
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v3
+      - name: Set Up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install Dependencies
+        run: gem install yard
+      - name: Generate Documentation
+        run: yardoc
+      - name: Deploy to GitHub Pages
+        uses: peaceiris/actions-gh-pages@v4.0.0
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: ./doc

data/.github/workflows/main.yml

@@ -9,8 +9,6 @@ jobs:
     name: Ruby ${{ matrix.ruby }}
     env:
       RAILS_ENV: test
-      CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}
-      DATABASE_URL: "postgres://rails:password@localhost:5432/rails_test"
     strategy:
       matrix:
         ruby:
@@ -24,6 +22,7 @@ jobs:
           POSTGRES_DB: rails_test
           POSTGRES_USER: rails
           POSTGRES_PASSWORD: password
+          DATABASE_URL: "postgres://rails:password@localhost:5432/rails_test"
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
     steps:
     - name: Checkout code
@@ -40,3 +39,5 @@ jobs:
       run: bundle exec rake
     - name: Publish code coverage
       uses: paambaati/codeclimate-action@v9.0.0
+      env:
+        CC_TEST_REPORTER_ID: ${{ secrets.CC_TEST_REPORTER_ID }}

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## [1.1.0](https://github.com/shivam091/postgresql_adapter_extensions/compare/v1.0.0...v1.1.0) - 2025-03-21
+
+### What's new
+- Extended `ActiveRecord::Migration::CommandRecorder` to support PostgreSQL sequence-related commands.
+- Added `create_sequence` method to record sequence creation in migrations.
+- Added `alter_sequence` method to record sequence alterations (irreversible).
+- Added `drop_sequence` method to record sequence deletions (irreversible).
+- Implemented `invert_create_sequence` to allow rollback by dropping the sequence.
+- Implemented `invert_alter_sequence` and `invert_drop_sequence` to raise `ActiveRecord::IrreversibleMigration`.
+
+### Notes
+- `create_sequence` can be reversed by dropping the sequence.
+- `alter_sequence` and `drop_sequence` are irreversible operations.
+
+----------
+
+## [1.0.0](https://github.com/shivam091/postgresql_adapter_extensions/compare/v0.1.0...v1.0.0) - 2025-03-12
+
+### What's new
+
+- Added `create_sequence` method
+
+  Allows creating PostgreSQL sequences with customizable options such as start value, increment step, min/max values, caching, cycling, and ownership.
+
+- Added `alter_sequence` method
+
+  Enables modifying existing PostgreSQL sequences, supporting changes to increment steps, restart values, min/max limits, caching, cycling behavior, and ownership.
+
+- Added `drop_sequence` method
+
+  Provides functionality to remove a PostgreSQL sequence with optional IF EXISTS and CASCADE/RESTRICT behaviors to manage dependencies.
+
+----------
+
 ## 0.1.0 - 2025-03-11
 
 ### Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    postgresql_adapter_extensions (0.1.0)
+    postgresql_adapter_extensions (1.1.0)
       activerecord (~> 8)
       pg (~> 1.5)
 

data/README.md

@@ -1,4 +1,30 @@
 # PostgreSQLAdapterExtensions
+
+PostgreSQL Adapter Extensions for ActiveRecord.
+
+`postgresql_adapter_extensions` is a Ruby gem that extends the `ActiveRecord::ConnectionAdapters::PostgreSQLAdapter`
+to add additional sequence-related methods for managing PostgreSQL sequences in a Rails application.
+
+[![Ruby](https://github.com/shivam091/postgresql_adapter_extensions/actions/workflows/main.yml/badge.svg)](https://github.com/shivam091/postgresql_adapter_extensions/actions/workflows/main.yml)
+[![Gem Version](https://badge.fury.io/rb/postgresql_adapter_extensions.svg)](https://badge.fury.io/rb/postgresql_adapter_extensions)
+[![Gem Downloads](https://img.shields.io/gem/dt/postgresql_adapter_extensions.svg)](http://rubygems.org/gems/postgresql_adapter_extensions)
+[![Maintainability](https://api.codeclimate.com/v1/badges/be55ce822a1f617f6bdd/maintainability)](https://codeclimate.com/github/shivam091/postgresql_adapter_extensions/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/be55ce822a1f617f6bdd/test_coverage)](https://codeclimate.com/github/shivam091/postgresql_adapter_extensions/test_coverage)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/shivam091/postgresql_adapter_extensions/blob/main/LICENSE.md)
+
+[Harshal V. Ladhe, Master of Computer Science.](https://shivam091.github.io)
+
+## Introduction
+
+This gem provides easy-to-use methods to create, alter, and drop sequences, which can be useful for handling
+auto-incrementing IDs and other sequence-based logic in your database.
+
+## Minimum Requirements
+
+* Ruby 3.3+ ([Download Ruby](https://www.ruby-lang.org/en/downloads/branches/))
+* Rails 8.0.0+ ([RubyGems - Rails Versions](https://rubygems.org/gems/rails/versions))
+* ActiveRecord 8.0.0+ (comes with Rails)
+
 ## Installation
 
 To use `postgresql_adapter_extensions` in your Rails application, add the following line to your Gemfile:
@@ -15,6 +41,170 @@ Or otherwise simply install it yourself as:
 
 `$ gem install postgresql_adapter_extensions`
 
+## Usage
+
+### create_sequence
+
+The `create_sequence` method allows you to create a new sequence in your PostgreSQL database with customizable options. A sequence is typically used to auto-generate unique values for primary keys or other incrementing columns.
+
+```ruby
+create_sequence(name, options = {})
+```
+
+**Create a sequence with default options:**
+
+```ruby
+create_sequence(:order_id_seq)
+```
+
+**Create a sequence starting from 1000 with an increment of 5:**
+
+```ruby
+create_sequence(:order_id_seq, start: 1000, increment_by: 5)
+```
+
+**Create a cyclic sequence with a maximum value of 5000:**
+
+```ruby
+create_sequence(:order_id_seq, cycle: true, maxvalue: 5000)
+```
+
+**Create a sequence owned by a specific table and column:**
+
+```ruby
+create_sequence(:order_id_seq, owned_by: "orders.id")
+```
+
+### alter_sequence
+
+The `alter_sequence` method allows you to modify an existing sequence in your PostgreSQL database.
+You can change various attributes of the sequence, such as its increment, start value, maximum value,
+cycle behavior, and ownership.
+
+```ruby
+alter_sequence(name, options = {})
+```
+
+**Modify the increment value of a sequence:**
+
+```ruby
+alter_sequence(:order_id_seq, increment_by: 10)
+```
+
+**Restart a sequence at a specific value:**
+
+```ruby
+alter_sequence(:order_id_seq, restart_with: 2000)
+```
+
+**Set a minimum and maximum value for a sequence:**
+
+```ruby
+alter_sequence(:order_id_seq, minvalue: 500, maxvalue: 10000)
+```
+
+**Make a sequence cycle when it reaches the maximum value:**
+
+```ruby
+alter_sequence(:order_id_seq, cycle: true)
+```
+
+**Remove the cycle behavior from a sequence:**
+
+```ruby
+alter_sequence(:order_id_seq, cycle: false)
+```
+
+**Change the owner of a sequence to a specific table column:**
+
+```ruby
+alter_sequence(:order_id_seq, owned_by: "orders.id")
+```
+
+This method provides flexibility in managing sequences dynamically in your Rails application,
+ ensuring that sequence-related database behavior can be modified as needed.
+
+### drop_sequence
+
+The `drop_sequence` method allows you to drop an existing sequence from your PostgreSQL database, with options to control its behavior.
+
+```ruby
+drop_sequence(name, options = {})
+```
+
+**Drop a sequence without additional options:**
+
+ ```ruby
+drop_sequence(:order_id_seq)
+```
+
+**Drop a sequence if it exists:**
+
+```ruby
+drop_sequence(:order_id_seq, if_exists: true)
+```
+
+**Drop a sequence and all dependent objects:**
+
+```ruby
+drop_sequence(:order_id_seq, drop_behavior: :cascade)
+```
+
+**Drop a sequence but prevent deletion if dependencies exist:**
+
+```ruby
+drop_sequence(:order_id_seq, drop_behavior: :restrict)
+```
+
+## PostgreSQL Setup for Contributors
+
+If you're contributing to this gem and need to set up PostgreSQL for local development or testing,
+you can use the provided setup script. This script will help you create the necessary PostgreSQL
+user and database for testing.
+
+### Running the Setup Script
+
+1. **Clone the repository** and navigate to the root directory of the gem.
+2. Make sure you have PostgreSQL installed and running on your machine.
+3. Run the script using the following command:
+
+   `$ ./bin/setup_postgresql.sh`
+
+   By default, the script will use the following values unless environment variables are set:
+
+   1. Database Name: `rails_test`
+   2. Username: `rails`
+   3. Password: `password`
+
+4. If you want to override these defaults, set the environment variables before running the script:
+
+   `$ POSTGRES_DB=rails_test POSTGRES_USER=rails POSTGRES_PASSWORD=password ./bin/setup_postgresql.sh`
+
+5. The script will:
+
+   - Check if the specified PostgreSQL user exists, creating it if necessary.
+   - Check if the specified database exists, creating it if necessary.
+   - Grant the required privileges to the user for the database.
+
+***Note: This script is only required if you're contributing to the development of the gem or testing locally. It is not required for end users of the gem.***
+
+## Tests
+
+The gem includes RSpec tests to verify that the sequence methods behave as expected.
+
+### Running the Tests
+
+To run the tests, you need to install the required dependencies first:
+
+`$ bundle install`
+
+Then, run the tests with:
+
+`$ bundle exec rspec`
+
+The tests are located in the `spec/` directory and verify the behavior of `create_sequence`,
+`alter_sequence`, and `drop_sequence` methods.
+
 ## Contributing
 
 Contributions to this project are welcomed! To contribute:

data/bin/setup_postgresql.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Exit immediately if any command fails
+set -e
+
+echo "🔧 Setting up PostgreSQL for testing..."
+
+# Read input from ENV variables or use default one
+POSTGRES_DB=${POSTGRES_DB:-"rails_test"}
+POSTGRES_USER=${POSTGRES_USER:-"rails"}
+POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-"password"}
+
+# Check if the user exists, create if not
+echo "👤 Checking if user '$POSTGRES_USER' exists..."
+USER_EXISTS=$(sudo -u postgres psql -tAc "SELECT 1 FROM pg_roles WHERE rolname='$POSTGRES_USER'")
+
+if [[ "$USER_EXISTS" != "1" ]]; then
+  echo "👤 Creating user '$POSTGRES_USER'..."
+  sudo -u postgres psql -c "CREATE USER $POSTGRES_USER WITH SUPERUSER;"
+  echo "🔑 Setting password for user '$POSTGRES_USER'..."
+  sudo -u postgres psql -c "ALTER USER $POSTGRES_USER WITH PASSWORD '$POSTGRES_PASSWORD';"
+else
+  echo "✅ User '$POSTGRES_USER' already exists."
+fi
+
+# Check if the database exists, create if not
+echo "📦 Checking if database '$POSTGRES_DB' exists..."
+DB_EXISTS=$(sudo -u postgres psql -tAc "SELECT 1 FROM pg_database WHERE datname='$POSTGRES_DB'")
+
+if [[ "$DB_EXISTS" != "1" ]]; then
+  echo "📦 Creating database '$POSTGRES_DB'..."
+  sudo -u postgres psql -c "CREATE DATABASE $POSTGRES_DB OWNER $POSTGRES_USER;"
+else
+  echo "✅ Database '$POSTGRES_DB' already exists."
+fi
+
+# Grant privileges to the user on the database
+echo "🔑 Granting privileges to '$POSTGRES_USER' on '$POSTGRES_DB'..."
+sudo -u postgres psql -c "GRANT ALL PRIVILEGES ON DATABASE $POSTGRES_DB TO $POSTGRES_USER;"
+
+echo "✅ PostgreSQL setup complete!"

data/lib/postgresql_adapter_extensions/base.rb

@@ -5,11 +5,23 @@
 require "active_record"
 require "active_record/connection_adapters/postgresql_adapter"
 
-module PostgreSQLAdapterExtensions
+require "postgresql_adapter_extensions/command_recorder"
+require "postgresql_adapter_extensions/sequence_methods"
 
+module PostgreSQLAdapterExtensions
+  ##
   # This is the base class for custom errors in the +PostgreSQLAdapterExtensions+ module.
   #
   # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
   # @since 0.1.0
+  #
   class BaseError < StandardError; end
+
+  if defined?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.include(SequenceMethods)
+  end
+
+  if defined?(ActiveRecord::Migration::CommandRecorder)
+    ActiveRecord::Migration::CommandRecorder.include(CommandRecorder)
+  end
 end

data/lib/postgresql_adapter_extensions/command_recorder.rb

@@ -0,0 +1,121 @@
+# -*- encoding: utf-8 -*-
+# -*- frozen_string_literal: true -*-
+# -*- warn_indent: true -*-
+
+module PostgreSQLAdapterExtensions
+  ##
+  # Module that extends ActiveRecord's CommandRecorder to handle sequence-related commands.
+  #
+  # This module is designed to work with reversible migrations in ActiveRecord, specifically to manage PostgreSQL sequence operations.
+  # The methods capture forward migration commands for sequences and generate their inverse using simple metaprogramming.
+  #
+  # @example
+  #   class AddSomeSequence < ActiveRecord::Migration[6.0]
+  #     def change
+  #       create_sequence :some_sequence
+  #     end
+  #   end
+  #
+  # This will create a sequence, and during rollback, it will drop the sequence.
+  #
+  # @see ActiveRecord::Migration::CommandRecorder
+  #
+  # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+  # @since 1.0.0
+  #
+  module CommandRecorder
+    ##
+    # Records the creation of a PostgreSQL sequence during a migration.
+    #
+    # This method is invoked when creating a sequence in the database. The corresponding
+    # inverse operation will be to drop the sequence during rollback.
+    #
+    # @param args [Array] Arguments required to create the sequence (usually the sequence name).
+    # @param block [Proc] An optional block passed to the command.
+    # @return [void]
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def create_sequence(*args, &block)
+      record(:create_sequence, args, &block)
+    end
+
+    ##
+    # Records the alteration of a PostgreSQL sequence during a migration.
+    #
+    # This method is invoked when altering a sequence in the database.
+    # The corresponding inverse operation is not possible, so it will raise an error during rollback.
+    #
+    # @param args [Array] Arguments required to alter the sequence.
+    # @param block [Proc] An optional block passed to the command.
+    # @raise [ActiveRecord::IrreversibleMigration] When attempting to rollback an altered sequence.
+    # @return [void]
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def alter_sequence(*args, &block)
+      record(:alter_sequence, args, &block)
+    end
+
+    ##
+    # Records the dropping of a PostgreSQL sequence during a migration.
+    #
+    # This method is invoked when dropping a sequence from the database.
+    # The corresponding inverse operation is not possible, so it will raise an error during rollback.
+    #
+    # @param args [Array] Arguments required to drop the sequence (usually the sequence name).
+    # @param block [Proc] An optional block passed to the command.
+    # @raise [ActiveRecord::IrreversibleMigration] When attempting to rollback a dropped sequence.
+    # @return [void]
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def drop_sequence(*args, &block)
+      record(:drop_sequence, args, &block)
+    end
+
+    private
+
+    ##
+    # Generates the inverse command for creating a sequence, which is to drop the sequence.
+    #
+    # @param args [Array] Arguments passed to the create_sequence method (sequence name).
+    # @return [Array] An array with the inverse command `:drop_sequence` and its arguments.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def invert_create_sequence(args)
+      [:drop_sequence, args]
+    end
+
+    ##
+    # Generates the inverse command for altering a sequence, which is not possible.
+    #
+    # @param args [Array] Arguments passed to the alter_sequence method.
+    # @raise [ActiveRecord::IrreversibleMigration] This operation cannot be reversed.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def invert_alter_sequence(args)
+      raise ActiveRecord::IrreversibleMigration, "Alter sequence is irreversible."
+    end
+
+    ##
+    # Generates the inverse command for dropping a sequence, which is not possible.
+    #
+    # @param args [Array] Arguments passed to the drop_sequence method (sequence name).
+    # @raise [ActiveRecord::IrreversibleMigration] This operation cannot be reversed.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def invert_drop_sequence(args)
+      raise ActiveRecord::IrreversibleMigration, "Drop sequence is irreversible."
+    end
+  end
+end

data/lib/postgresql_adapter_extensions/sequence_methods.rb

@@ -0,0 +1,179 @@
+# -*- encoding: utf-8 -*-
+# -*- frozen_string_literal: true -*-
+# -*- warn_indent: true -*-
+
+module PostgreSQLAdapterExtensions
+  ##
+  # This module provides methods for managing PostgreSQL sequences, including
+  # creating, altering, and dropping sequences with various customization options.
+  #
+  # @note This module is designed for PostgreSQL databases and may not be compatible with other database systems.
+  #
+  # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+  # @since 1.0.0
+  #
+  module SequenceMethods
+    ##
+    # Creates a new sequence in the PostgreSQL database with customizable options.
+    #
+    # @param name [String, Symbol] The name of the sequence to create.
+    # @param options [Hash] Additional options to configure the sequence.
+    # @option options [Boolean] :if_not_exists (false) Includes +IF NOT EXISTS+ to avoid errors if the sequence exists.
+    # @option options [String, nil] :data_type (nil) Sets the sequence's data type (e.g., +BIGINT+, +SMALLINT+).
+    # @option options [Integer] :start (1) The starting value of the sequence.
+    # @option options [Integer] :increment_by (1) The increment step for each sequence value.
+    # @option options [Integer, nil] :minvalue (1) The minimum value the sequence can generate. Uses +NO MINVALUE+ if nil.
+    # @option options [Integer, nil] :maxvalue (nil) The maximum value the sequence can generate. Uses +NO MAXVALUE+ if nil.
+    # @option options [Integer] :cache (1) The number of sequence values to cache for performance.
+    # @option options [Boolean] :cycle (false) Whether the sequence should cycle back to the start after reaching the max value.
+    # @option options [String, nil] :owned_by (nil) The table and column name that owns this sequence.
+    #
+    # @example Create a sequence with default options
+    #   create_sequence(:order_id_seq)
+    #
+    # @example Create a sequence starting from 1000 with an increment of 5
+    #   create_sequence(:order_id_seq, start: 1000, increment_by: 5)
+    #
+    # @example Create a cyclic sequence with a maximum value of 5000
+    #   create_sequence(:order_id_seq, cycle: true, maxvalue: 5000)
+    #
+    # @example Create a sequence owned by a specific table column
+    #   create_sequence(:order_id_seq, owned_by: "orders.id")
+    #
+    # @return [void]
+    #
+    # @note Uses `CREATE SEQUENCE` SQL statement with PostgreSQL-specific options.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def create_sequence(name, options = {})
+      options = options.reverse_merge(
+        start: 1,
+        increment_by: 1,
+        minvalue: 1,
+        cache: 1,
+        cycle: false,
+        if_not_exists: false
+      )
+
+      sql = +"CREATE SEQUENCE"
+      sql << " IF NOT EXISTS" if options[:if_not_exists]
+      sql << " #{quote_table_name(name)}"
+
+      sql << " AS #{options[:data_type]}" if options[:data_type]
+      sql << " INCREMENT BY #{options[:increment_by]}" if options[:increment_by]
+      sql << (options[:minvalue] ? " MINVALUE #{options[:minvalue]}" : " NO MINVALUE")
+      sql << (options[:maxvalue] ? " MAXVALUE #{options[:maxvalue]}" : " NO MAXVALUE")
+      sql << " START WITH #{options[:start]}" if options[:start]
+      sql << " CACHE #{options[:cache]}" if options[:cache]
+      sql << " #{options[:cycle] ? 'CYCLE' : 'NO CYCLE'}"
+      sql << " OWNED BY #{options[:owned_by]}" if options[:owned_by]
+
+      execute(sql).tap { reload_type_map }
+    end
+
+    ##
+    # Alters an existing PostgreSQL sequence with the given options.
+    #
+    # @param name [String, Symbol] The name of the sequence to alter.
+    # @param options [Hash] A hash of options to modify the sequence behavior.
+    # @option options [Boolean] :if_exists Includes +IF EXISTS+ to avoid errors if the sequence does not exist.
+    # @option options [String, nil] :data_type Sets the sequence's data type (e.g., +BIGINT+, +SMALLINT+).
+    # @option options [Integer] :increment_by Sets the increment step for the sequence.
+    # @option options [Integer, nil] :minvalue Sets the minimum value for the sequence. Uses +NO MINVALUE+ if nil.
+    # @option options [Integer, nil] :maxvalue Sets the maximum value for the sequence. Uses +NO MAXVALUE+ if nil.
+    # @option options [Integer] :start Sets the starting value of the sequence.
+    # @option options [Integer, nil] :restart Restarts the sequence. Uses +RESTART+ if nil, +RESTART WITH value+ if provided.
+    # @option options [Integer] :cache Sets the number of sequence values to cache for performance.
+    # @option options [Boolean] :cycle Enables (+CYCLE+) or disables (+NO CYCLE+) sequence cycling.
+    # @option options [String, nil] :owned_by Associates the sequence with a table column. Uses +OWNED BY NONE+ if nil.
+    #
+    # @example Modify the increment value of a sequence
+    #   alter_sequence(:order_id_seq, increment_by: 10)
+    #
+    # @example Restart a sequence at a specific value
+    #   alter_sequence(:order_id_seq, restart_with: 2000)
+    #
+    # @example Set a minimum and maximum value for a sequence
+    #   alter_sequence(:order_id_seq, minvalue: 500, maxvalue: 10000)
+    #
+    # @example Make a sequence cycle when it reaches the maximum value
+    #   alter_sequence(:order_id_seq, cycle: true)
+    #
+    # @example Remove the cycle behavior from a sequence
+    #   alter_sequence(:order_id_seq, cycle: false)
+    #
+    # @example Change the owner of a sequence to a specific table column
+    #   alter_sequence(:order_id_seq, owned_by: "orders.id")
+    #
+    # @return [void] Executes the SQL statement to alter the sequence.
+    #
+    # @note Uses `ALTER SEQUENCE` SQL statement with PostgreSQL-specific options.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def alter_sequence(name, options = {})
+      sql = +"ALTER SEQUENCE"
+      sql << " IF EXISTS" if options[:if_exists]
+      sql << " #{quote_table_name(name)}"
+
+      sql << " AS #{options[:data_type]}" if options[:data_type]
+      sql << " INCREMENT BY #{options[:increment_by]}" if options[:increment_by]
+      sql << (options[:minvalue] ? " MINVALUE #{options[:minvalue]}" : " NO MINVALUE")
+      sql << (options[:maxvalue] ? " MAXVALUE #{options[:maxvalue]}" : " NO MAXVALUE")
+      sql << " START WITH #{options[:start]}" if options[:start]
+      sql << " RESTART" if options[:restart].nil? && options.key?(:restart)
+      sql << " RESTART WITH #{options[:restart]}" if options[:restart]
+      sql << " CACHE #{options[:cache]}" if options[:cache]
+      sql << " #{options[:cycle] ? 'CYCLE' : 'NO CYCLE'}"
+      sql << (options[:owned_by] ? " OWNED BY #{options[:owned_by]}" : " OWNED BY NONE")
+
+      execute(sql).tap { reload_type_map }
+    end
+
+    ##
+    # Drops an existing sequence from the PostgreSQL database with optional conditions.
+    #
+    # @param name [String, Symbol] The name of the sequence to drop.
+    # @param options [Hash] Additional options to modify the behavior of the drop operation.
+    # @option options [Boolean] :if_exists (false) Adds +IF EXISTS+ to avoid errors if the sequence does not exist.
+    # @option options [Symbol] :drop_behavior (nil) Determines whether dependent objects are also dropped.
+    #   - Accepts +:cascade+ to drop dependent objects.
+    #   - Accepts +:restrict+ to prevent dropping if dependencies exist.
+    #
+    # @example Drop a sequence without additional options
+    #   drop_sequence(:order_id_seq)
+    #
+    # @example Drop a sequence if it exists
+    #   drop_sequence(:order_id_seq, if_exists: true)
+    #
+    # @example Drop a sequence and all dependent objects
+    #   drop_sequence(:order_id_seq, drop_behavior: :cascade)
+    #
+    # @example Drop a sequence but prevent deletion if dependencies exist
+    #   drop_sequence(:order_id_seq, drop_behavior: :restrict)
+    #
+    # @return [void]
+    #
+    # @note Uses `DROP SEQUENCE` SQL statement with PostgreSQL-specific options.
+    #
+    # @author {Harshal V. Ladhe}[https://shivam091.github.io/]
+    # @since 1.0.0
+    #
+    def drop_sequence(name, options = {})
+      options = options.reverse_merge(
+        if_exists: false
+      )
+
+      sql = +"DROP SEQUENCE"
+      sql << " IF EXISTS" if options[:if_exists]
+      sql << " #{quote_table_name(name)}"
+
+      sql << " #{options[:drop_behavior].to_s.upcase}" if options[:drop_behavior].in?([:cascade, :restrict])
+
+      execute(sql).tap { reload_type_map }
+    end
+  end
+end

data/lib/postgresql_adapter_extensions/version.rb

@@ -4,5 +4,5 @@
 
 module PostgreSQLAdapterExtensions
   # Current stable version.
-  VERSION = "0.1.0"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: postgresql_adapter_extensions
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Harshal LADHE
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2025-03-11 00:00:00.000000000 Z
+date: 2025-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -108,6 +108,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/docs.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".rspec"
@@ -117,8 +118,11 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/setup_postgresql.sh
 - lib/postgresql_adapter_extensions.rb
 - lib/postgresql_adapter_extensions/base.rb
+- lib/postgresql_adapter_extensions/command_recorder.rb
+- lib/postgresql_adapter_extensions/sequence_methods.rb
 - lib/postgresql_adapter_extensions/version.rb
 - postgresql_adapter_extensions.gemspec
 homepage: https://github.com/shivam091/postgresql_adapter_extensions