mat_views 0.1.2 → 0.2.0

data/lib/mat_views/services/swap_refresh.rb

@@ -21,102 +21,106 @@ module MatViews
     # 2. In a transaction: rename original → old, tmp → original, drop old.
     # 3. Recreate declared unique indexes (if any).
     #
-    # Supports optional row count strategies:
-    # - `:estimated` → approximate, using `pg_class.reltuples`
-    # - `:exact` → accurate, using `COUNT(*)`
-    # - `nil` → skip row count
+    # Options:
+    # - `row_count_strategy:` (Symbol, default: :none) → one of `:estimated`, `:exact`, or `:none or nil` to control row count reporting
     #
-    # @return [MatViews::ServiceResponse]
+    # Returns a {MatViews::ServiceResponse}
     #
-    # @example
-    #   svc = MatViews::Services::SwapRefresh.new(defn, row_count_strategy: :exact)
-    #   svc.run
+    # @see MatViews::Services::ConcurrentRefresh
+    # @see MatViews::Services::RegularRefresh
+    #
+    # @example Direct usage
+    #   svc = MatViews::Services::SwapRefresh.new(definition, **options)
+    #   response = svc.run
+    #   response.success? # => true/false
+    #
+    # @example via job, this is the typical usage and will create a run record in the DB
+    #   When definition.refresh_strategy == "concurrent"
+    #   MatViews::Jobs::Adapter.enqueue(MatViews::Services::SwapRefresh, definition.id, **options)
     #
     class SwapRefresh < BaseService
-      ##
-      # Row count strategy (`:estimated`, `:exact`, `nil`).
-      #
-      # @return [Symbol, nil]
-      attr_reader :row_count_strategy
-
-      ##
-      # @param definition [MatViews::MatViewDefinition]
-      # @param row_count_strategy [Symbol, nil]
-      def initialize(definition, row_count_strategy: :estimated)
-        super(definition)
-        @row_count_strategy = row_count_strategy
-      end
+      private
 
       ##
       # Execute the swap refresh.
       #
       # @return [MatViews::ServiceResponse]
-      def run
-        prep = prepare!
-        return prep if prep
-
-        create_sql = %(CREATE MATERIALIZED VIEW #{q_tmp} AS #{definition.sql} WITH DATA)
-        steps = [create_sql]
-        conn.execute(create_sql)
-
-        steps.concat(swap_index)
-
-        payload = { view: "#{schema}.#{rel}" }
-        payload[:row_count] = fetch_rows_count if row_count_strategy.present?
-
-        ok(:updated, payload: payload, meta: { steps: steps, row_count_strategy: row_count_strategy, swap: true })
-      rescue StandardError => e
-        error_response(e,
-                       meta: {
-                         steps: steps,
-                         backtrace: Array(e.backtrace),
-                         row_count_strategy: row_count_strategy,
-                         swap: true
-                       },
-                       payload: { view: "#{schema}.#{rel}" })
-      end
+      #   - `status: :updated` on success, with `response` containing:
+      #     - `view` - the qualified view name
+      #     - `row_count_before` - if requested and available
+      #     - `row_count_after` - if requested and available
+      #   - `status: :error` with `error` on failure, with `error` containing:
+      #     - serlialized exception class, message, and backtrace in a hash
+      #
+      def _run
+        self.response = { view: "#{schema}.#{rel}" }
 
-      private
+        response[:row_count_before] = fetch_rows_count
+        response[:sql] = swap_view
+        response[:row_count_after] = fetch_rows_count
 
-      # ────────────────────────────────────────────────────────────────
-      # internal
-      # ────────────────────────────────────────────────────────────────
+        ok(:updated)
+      end
 
       ##
       # Ensure name validity and existence of original view.
       #
       # @api private
       # @return [MatViews::ServiceResponse, nil]
-      def prepare!
-        return err("Invalid view name format: #{definition.name.inspect}") unless valid_name?
-        return err("Materialized view #{schema}.#{rel} does not exist") unless view_exists?
+      def prepare
+        raise_err "Invalid view name format: #{definition.name.inspect}" unless valid_name?
+        raise_err "Materialized view #{schema}.#{rel} does not exist" unless view_exists?
 
         nil
       end
 
+      ##
+      # Assign the request parameters.
+      # Called by {#run} before {#prepare}.
+      #
+      # @api private
+      # @return [void]
+      #
+      def assign_request
+        self.request = { row_count_strategy: row_count_strategy, swap: true }
+      end
+
       ##
       # Perform rename/drop/index recreation in a transaction.
       #
       # @api private
       # @return [Array<String>] SQL steps executed
-      def swap_index
-        steps = []
+      def swap_view
+        conn.execute(create_temp_view_sql)
+        steps = [
+          move_current_to_old_sql,
+          move_temp_to_current_sql,
+          drop_old_view_sql,
+          recreate_declared_unique_indexes_sql
+        ].compact
         conn.transaction do
-          rename_orig_sql = %(ALTER MATERIALIZED VIEW #{qualified_rel} RENAME TO #{conn.quote_column_name(old_rel)})
-          steps << rename_orig_sql
-          conn.execute(rename_orig_sql)
+          steps.each { |step| conn.execute(step) }
+        end
 
-          rename_tmp_sql = %(ALTER MATERIALIZED VIEW #{q_tmp} RENAME TO #{conn.quote_column_name(rel)})
-          steps << rename_tmp_sql
-          conn.execute(rename_tmp_sql)
+        # prepend the create step
+        steps.unshift(create_temp_view_sql)
+        steps
+      end
 
-          drop_old_sql = %(DROP MATERIALIZED VIEW #{q_old})
-          steps << drop_old_sql
-          conn.execute(drop_old_sql)
+      def create_temp_view_sql
+        @create_temp_view_sql ||= %(CREATE MATERIALIZED VIEW #{q_tmp} AS #{definition.sql} WITH DATA)
+      end
 
-          recreate_declared_unique_indexes!(schema:, rel:, steps:)
-        end
-        steps
+      def move_current_to_old_sql
+        %(ALTER MATERIALIZED VIEW #{qualified_rel} RENAME TO #{conn.quote_column_name(old_rel)})
+      end
+
+      def move_temp_to_current_sql
+        %(ALTER MATERIALIZED VIEW #{q_tmp} RENAME TO #{conn.quote_column_name(rel)})
+      end
+
+      def drop_old_view_sql
+        %(DROP MATERIALIZED VIEW #{q_old})
       end
 
       ##
@@ -159,62 +163,16 @@ module MatViews
       # Recreate declared unique indexes on the swapped-in view.
       #
       # @api private
-      # @param schema [String]
-      # @param rel [String]
-      # @param steps [Array<String>] collected SQL
-      def recreate_declared_unique_indexes!(schema:, rel:, steps:)
+      # @return [String] SQL statements to execute
+      def recreate_declared_unique_indexes_sql
         cols = Array(definition.unique_index_columns).map(&:to_s).reject(&:empty?)
-        return if cols.empty?
+        return nil if cols.empty?
 
-        quoted_cols = cols.map { |c| conn.quote_column_name(c) }.join(', ')
+        quoted_cols = cols.map { |col| conn.quote_column_name(col) }.join(', ')
         idx_name    = conn.quote_column_name("#{rel}_uniq_#{cols.join('_')}")
         q_rel       = conn.quote_table_name("#{schema}.#{rel}")
 
-        sql = %(CREATE UNIQUE INDEX #{idx_name} ON #{q_rel} (#{quoted_cols}))
-        steps << sql
-        conn.execute(sql)
-      end
-
-      # ────────────────────────────────────────────────────────────────
-      # rows counting
-      # ────────────────────────────────────────────────────────────────
-
-      ##
-      # Fetch the row count based on the configured strategy.
-      #
-      # @api private
-      # @return [Integer, nil]
-      def fetch_rows_count
-        case row_count_strategy
-        when :estimated then estimated_rows_count
-        when :exact     then exact_rows_count
-        end
-      end
-
-      ##
-      # Approximate row count via `pg_class.reltuples`.
-      #
-      # @api private
-      # @return [Integer]
-      def estimated_rows_count
-        conn.select_value(<<~SQL).to_i
-          SELECT COALESCE(c.reltuples::bigint, 0)
-          FROM pg_class c
-          JOIN pg_namespace n ON n.oid = c.relnamespace
-          WHERE c.relkind IN ('m','r','p')
-            AND n.nspname = #{conn.quote(schema)}
-            AND c.relname = #{conn.quote(rel)}
-          LIMIT 1
-        SQL
-      end
-
-      ##
-      # Accurate row count via `COUNT(*)`.
-      #
-      # @api private
-      # @return [Integer]
-      def exact_rows_count
-        conn.select_value("SELECT COUNT(*) FROM #{qualified_rel}").to_i
+        %(CREATE UNIQUE INDEX #{idx_name} ON #{q_rel} (#{quoted_cols}))
       end
     end
   end

data/lib/mat_views/version.rb

@@ -17,5 +17,5 @@ module MatViews
   # - PATCH: Backwards-compatible bug fixes
   #
   # @return [String] the current gem version
-  VERSION = '0.1.2'
+  VERSION = '0.2.0'
 end

data/lib/mat_views.rb

@@ -5,6 +5,7 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
+require 'ext/exception'
 require 'mat_views/version'
 require 'mat_views/engine'
 require 'mat_views/configuration'
@@ -40,7 +41,7 @@ module MatViews
   class << self
     # Global configuration for MatViews
     # @return [MatViews::Configuration]
-    attr_accessor :configuration
+    attr_reader :configuration
 
     # Configure MatViews via block.
     #
@@ -50,7 +51,7 @@ module MatViews
     #     config.job_queue   = :materialized
     #   end
     def configure
-      self.configuration ||= Configuration.new
+      @configuration ||= Configuration.new
       yield(configuration)
     end
   end

data/lib/tasks/helpers.rb

@@ -51,12 +51,12 @@ module MatViews
       end
 
       # Parse row count strategy from arg or ROW_COUNT_STRATEGY env.
-      # Defaults to :estimated if blank.
+      # Defaults to :none if blank.
       def parse_row_count_strategy(arg)
-        s = (arg || ENV.fetch('ROW_COUNT_STRATEGY', nil)).to_s.strip
-        return :estimated if s.empty?
+        str = (arg || ENV.fetch('ROW_COUNT_STRATEGY', nil)).to_s.strip
+        return :none if str.empty?
 
-        s.to_sym
+        str.to_sym
       end
 
       # Check if a materialized view exists in schema.
@@ -78,14 +78,15 @@ module MatViews
       # @return [MatViews::MatViewDefinition]
       # @raise [RuntimeError] if no definition found or mismatch with DB
       def find_definition_by_name!(raw_name)
-        raise 'view_name is required' if raw_name.nil? || raw_name.to_s.strip.empty?
+        raw_name_string = raw_name&.to_s&.strip
+        raise 'view_name is required' unless raw_name_string && !raw_name_string.empty?
 
         schema, rel =
-          if raw_name.to_s.include?('.')
-            parts = raw_name.to_s.split('.', 2)
+          if raw_name_string.include?('.')
+            parts = raw_name_string.split('.', 2)
             [parts[0], parts[1]]
           else
-            [nil, raw_name.to_s]
+            [nil, raw_name_string]
           end
 
         defn = MatViews::MatViewDefinition.find_by(name: rel)
@@ -126,13 +127,13 @@ module MatViews
       #
       # @param definition_id [Integer] MatViewDefinition ID
       # @param force [Boolean] whether to force creation
+      # @param row_count_strategy [Symbol] :estimated or :exact or :none
       # @return [void]
-      def enqueue_create!(definition_id, force)
-        q = MatViews.configuration.job_queue || :default
+      def enqueue_create(definition_id, force, row_count_strategy)
         MatViews::Jobs::Adapter.enqueue(
           MatViews::CreateViewJob,
-          queue: q,
-          args: [definition_id, force]
+          queue: MatViews.configuration.job_queue || :default,
+          args: [definition_id, force, row_count_strategy]
         )
       end
 
@@ -144,11 +145,10 @@ module MatViews
       #
       # This method allows scheduling a refresh operation with the specified row count strategy.
       # It uses the configured job adapter to enqueue the job.
-      def enqueue_refresh!(definition_id, row_count_strategy)
-        q = MatViews.configuration.job_queue || :default
+      def enqueue_refresh(definition_id, row_count_strategy)
         MatViews::Jobs::Adapter.enqueue(
           MatViews::RefreshViewJob,
-          queue: q,
+          queue: MatViews.configuration.job_queue || :default,
           args: [definition_id, row_count_strategy]
         )
       end
@@ -168,16 +168,16 @@ module MatViews
       #
       # @param definition_id [Integer] MatViewDefinition ID
       # @param cascade [Boolean] whether to drop with CASCADE
+      # @param row_count_strategy [Symbol] :estimated or :exact or :none
       # @return [void]
       #
       # This method schedules a job to delete the materialized view, optionally with CASCADE.
       # It uses the configured job adapter to enqueue the job.
-      def enqueue_delete!(definition_id, cascade)
-        q = MatViews.configuration.job_queue || :default
+      def enqueue_delete(definition_id, cascade, row_count_strategy)
         MatViews::Jobs::Adapter.enqueue(
           MatViews::DeleteViewJob,
-          queue: q,
-          args: [definition_id, cascade]
+          queue: MatViews.configuration.job_queue || :default,
+          args: [definition_id, cascade, row_count_strategy]
         )
       end
     end

data/lib/tasks/mat_views_tasks.rake

@@ -10,33 +10,36 @@ namespace :mat_views do
   # ───────────── CREATE ─────────────
 
   desc 'Enqueue a CREATE for a specific view by its name (optionally schema-qualified)'
-  task :create_by_name, %i[view_name force yes] => :environment do |_t, args|
+  task :create_by_name, %i[view_name force row_count_strategy yes] => :environment do |_t, args|
+    rcs   = helpers.parse_row_count_strategy(args[:row_count_strategy])
     force = helpers.parse_force?(args[:force])
     skip  = helpers.skip_confirm?(args[:yes])
     defn  = helpers.find_definition_by_name!(args[:view_name])
 
-    helpers.confirm!("Enqueue CREATE for view=#{defn.name} (id=#{defn.id}), force=#{force}", skip: skip)
-    helpers.enqueue_create!(defn.id, force)
-    helpers.logger.info("[mat_views] Enqueued CreateViewJob for definition ##{defn.id} (#{defn.name}), force=#{force}")
+    helpers.confirm!("Enqueue CREATE for view=#{defn.name} (id=#{defn.id}), force=#{force}, row_count_strategy=#{rcs}", skip: skip)
+    helpers.enqueue_create(defn.id, force, rcs)
+    helpers.logger.info("[mat_views] Enqueued CreateViewJob for definition ##{defn.id} (#{defn.name}), force=#{force}, row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue a CREATE for a specific view by its definition ID'
-  task :create_by_id, %i[definition_id force yes] => :environment do |_t, args|
+  task :create_by_id, %i[definition_id force row_count_strategy yes] => :environment do |_t, args|
     raise 'mat_views:create_by_id requires a definition_id parameter' if args[:definition_id].to_s.strip.empty?
 
+    rcs   = helpers.parse_row_count_strategy(args[:row_count_strategy])
     force = helpers.parse_force?(args[:force])
     skip  = helpers.skip_confirm?(args[:yes])
 
     defn = MatViews::MatViewDefinition.find_by(id: args[:definition_id])
     raise "No MatViews::MatViewDefinition found for id=#{args[:definition_id]}" unless defn
 
-    helpers.confirm!("Enqueue CREATE for id=#{defn.id} (#{defn.name}), force=#{force}", skip: skip)
-    helpers.enqueue_create!(defn.id, force)
-    helpers.logger.info("[mat_views] Enqueued CreateViewJob for definition ##{defn.id} (#{defn.name}), force=#{force}")
+    helpers.confirm!("Enqueue CREATE for id=#{defn.id} (#{defn.name}), force=#{force}, row_count_strategy=#{rcs}", skip: skip)
+    helpers.enqueue_create(defn.id, force, rcs)
+    helpers.logger.info("[mat_views] Enqueued CreateViewJob for definition ##{defn.id} (#{defn.name}), force=#{force}, row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue CREATE jobs for ALL defined materialized views'
-  task :create_all, %i[force yes] => :environment do |_t, args|
+  task :create_all, %i[force row_count_strategy yes] => :environment do |_t, args|
+    rcs   = helpers.parse_row_count_strategy(args[:row_count_strategy])
     force = helpers.parse_force?(args[:force])
     skip  = helpers.skip_confirm?(args[:yes])
 
@@ -47,9 +50,9 @@ namespace :mat_views do
       next
     end
 
-    helpers.confirm!("Enqueue CREATE for ALL (#{count}) views, force=#{force}", skip: skip)
-    scope.find_each { |defn| helpers.enqueue_create!(defn.id, force) }
-    helpers.logger.info("[mat_views] Enqueued #{count} CreateViewJob(s), force=#{force}.")
+    helpers.confirm!("Enqueue CREATE for ALL (#{count}) views, force=#{force}, row_count_strategy=#{rcs}", skip: skip)
+    scope.find_each { |defn| helpers.enqueue_create(defn.id, force, rcs) }
+    helpers.logger.info("[mat_views] Enqueued #{count} CreateViewJob(s), force=#{force}, row_count_strategy=#{rcs}.")
   end
 
   # ───────────── REFRESH ─────────────
@@ -61,8 +64,8 @@ namespace :mat_views do
     defn = helpers.find_definition_by_name!(args[:view_name])
 
     helpers.confirm!("Enqueue REFRESH for view=#{defn.name} (id=#{defn.id}), row_count_strategy=#{rcs}", skip: skip)
-    helpers.enqueue_refresh!(defn.id, rcs)
-    helpers.logger.info("[mat_views] Enqueued RefreshViewJob for definition ##{defn.id} (#{defn.name}), row_count_strategy=#{rcs}")
+    helpers.enqueue_refresh(defn.id, rcs)
+    helpers.logger.info("[mat_views] Enqueued RefreshViewJob for definition ##{defn.id} (#{defn.name}), row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue a REFRESH for a specific view by its definition ID'
@@ -76,8 +79,8 @@ namespace :mat_views do
     raise "No MatViews::MatViewDefinition found for id=#{args[:definition_id]}" unless defn
 
     helpers.confirm!("Enqueue REFRESH for id=#{defn.id} (#{defn.name}), row_count_strategy=#{rcs}", skip: skip)
-    helpers.enqueue_refresh!(defn.id, rcs)
-    helpers.logger.info("[mat_views] Enqueued RefreshViewJob for definition ##{defn.id} (#{defn.name}), row_count_strategy=#{rcs}")
+    helpers.enqueue_refresh(defn.id, rcs)
+    helpers.logger.info("[mat_views] Enqueued RefreshViewJob for definition ##{defn.id} (#{defn.name}), row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue REFRESH jobs for ALL defined materialized views'
@@ -93,40 +96,43 @@ namespace :mat_views do
     end
 
     helpers.confirm!("Enqueue REFRESH for ALL (#{count}) views, row_count_strategy=#{rcs}", skip: skip)
-    scope.find_each { |defn| helpers.enqueue_refresh!(defn.id, rcs) }
+    scope.find_each { |defn| helpers.enqueue_refresh(defn.id, rcs) }
     helpers.logger.info("[mat_views] Enqueued #{count} RefreshViewJob(s), row_count_strategy=#{rcs}.")
   end
 
   # ───────────── DELETE ─────────────
 
   desc 'Enqueue a DELETE (DROP MATERIALIZED VIEW) for a specific view by its name (optionally schema-qualified)'
-  task :delete_by_name, %i[view_name cascade yes] => :environment do |_t, args|
+  task :delete_by_name, %i[view_name cascade row_count_strategy yes] => :environment do |_t, args|
     cascade = helpers.parse_cascade?(args[:cascade])
+    rcs     = helpers.parse_row_count_strategy(args[:row_count_strategy])
     skip    = helpers.skip_confirm?(args[:yes])
     defn    = helpers.find_definition_by_name!(args[:view_name])
 
-    helpers.confirm!("Enqueue DELETE for view=#{defn.name} (id=#{defn.id}), cascade=#{cascade}", skip: skip)
-    helpers.enqueue_delete!(defn.id, cascade)
-    helpers.logger.info("[mat_views] Enqueued DeleteViewJob for definition ##{defn.id} (#{defn.name}), cascade=#{cascade}")
+    helpers.confirm!("Enqueue DELETE for view=#{defn.name} (id=#{defn.id}), cascade=#{cascade}, row_count_strategy=#{rcs}", skip: skip)
+    helpers.enqueue_delete(defn.id, cascade, rcs)
+    helpers.logger.info("[mat_views] Enqueued DeleteViewJob for definition ##{defn.id} (#{defn.name}), cascade=#{cascade}, row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue a DELETE (DROP MATERIALIZED VIEW) for a specific view by its definition ID'
-  task :delete_by_id, %i[definition_id cascade yes] => :environment do |_t, args|
+  task :delete_by_id, %i[definition_id cascade row_count_strategy yes] => :environment do |_t, args|
     raise 'mat_views:delete_by_id requires a definition_id parameter' if args[:definition_id].to_s.strip.empty?
 
+    rcs     = helpers.parse_row_count_strategy(args[:row_count_strategy])
     cascade = helpers.parse_cascade?(args[:cascade])
     skip    = helpers.skip_confirm?(args[:yes])
 
     defn = MatViews::MatViewDefinition.find_by(id: args[:definition_id])
     raise "No MatViews::MatViewDefinition found for id=#{args[:definition_id]}" unless defn
 
-    helpers.confirm!("Enqueue DELETE for id=#{defn.id} (#{defn.name}), cascade=#{cascade}", skip: skip)
-    helpers.enqueue_delete!(defn.id, cascade)
-    helpers.logger.info("[mat_views] Enqueued DeleteViewJob for definition ##{defn.id} (#{defn.name}), cascade=#{cascade}")
+    helpers.confirm!("Enqueue DELETE for id=#{defn.id} (#{defn.name}), cascade=#{cascade}, row_count_strategy=#{rcs}", skip: skip)
+    helpers.enqueue_delete(defn.id, cascade, rcs)
+    helpers.logger.info("[mat_views] Enqueued DeleteViewJob for definition ##{defn.id} (#{defn.name}), cascade=#{cascade}, row_count_strategy=#{rcs}.")
   end
 
   desc 'Enqueue DELETE jobs for ALL defined materialized views'
-  task :delete_all, %i[cascade yes] => :environment do |_t, args|
+  task :delete_all, %i[cascade row_count_strategy yes] => :environment do |_t, args|
+    rcs     = helpers.parse_row_count_strategy(args[:row_count_strategy])
     cascade = helpers.parse_cascade?(args[:cascade])
     skip    = helpers.skip_confirm?(args[:yes])
 
@@ -137,9 +143,9 @@ namespace :mat_views do
       next
     end
 
-    helpers.confirm!("Enqueue DELETE for ALL (#{count}) views, cascade=#{cascade}", skip: skip)
-    scope.find_each { |defn| helpers.enqueue_delete!(defn.id, cascade) }
-    helpers.logger.info("[mat_views] Enqueued #{count} DeleteViewJob(s), cascade=#{cascade}.")
+    helpers.confirm!("Enqueue DELETE for ALL (#{count}) views, cascade=#{cascade}, row_count_strategy=#{rcs}", skip: skip)
+    scope.find_each { |defn| helpers.enqueue_delete(defn.id, cascade, rcs) }
+    helpers.logger.info("[mat_views] Enqueued #{count} DeleteViewJob(s), cascade=#{cascade}, row_count_strategy=#{rcs}.")
   end
 end
 # rubocop:enable Metrics/BlockLength

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mat_views
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Nitesh Purohit
@@ -49,6 +49,7 @@ files:
 - app/models/mat_views/mat_view_definition.rb
 - app/models/mat_views/mat_view_run.rb
 - config/routes.rb
+- lib/ext/exception.rb
 - lib/generators/mat_views/install/install_generator.rb
 - lib/generators/mat_views/install/templates/create_mat_view_definitions.rb
 - lib/generators/mat_views/install/templates/create_mat_view_runs.rb
@@ -89,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Manage and refresh PostgreSQL materialized views in Rails
 test_files: []