mat_views 0.1.2 → 0.3.0

data/lib/mat_views/services/swap_refresh.rb

@@ -10,10 +10,10 @@ require 'securerandom'
 module MatViews
   module Services
     ##
-    # Service that performs a **swap-style refresh** of a materialized view.
+    # Service that performs a **swap-style refresh** of a materialised view.
     #
     # Instead of locking the existing view, this strategy builds a new
-    # temporary materialized view and atomically swaps it in. This approach
+    # temporary materialised view and atomically swaps it in. This approach
     # minimizes downtime and allows for safer rebuilds of large views.
     #
     # Steps:
@@ -21,106 +21,112 @@ 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.call
+    #   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.
+      # Validation step (invoked by BaseService#call before execution).
+      # Ensures view exists.
       #
       # @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?
+      #
+      # @return [void]
+      #
+      def prepare
+        raise_err "Materialized view #{schema}.#{rel} does not exist" unless view_exists?
 
         nil
       end
 
+      ##
+      # Assign the request parameters.
+      # Called by {#call} 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
 
       ##
-      # Quote the temporary materialized view name.
+      # Quote the temporary materialised view name.
       #
       # @api private
       # @return [String] quoted temporary view name
@@ -129,7 +135,7 @@ module MatViews
       end
 
       ##
-      # Quote the original materialized view name.
+      # Quote the original materialised view name.
       #
       # @api private
       # @return [String] quoted original view name
@@ -159,62 +165,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.3.0'
 end

data/lib/mat_views.rb

@@ -5,8 +5,10 @@
 # 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/helpers/ui_test_ids'
 require 'mat_views/configuration'
 require 'mat_views/jobs/adapter'
 require 'mat_views/service_response'
@@ -16,13 +18,16 @@ require 'mat_views/services/regular_refresh'
 require 'mat_views/services/concurrent_refresh'
 require 'mat_views/services/swap_refresh'
 require 'mat_views/services/delete_view'
+require 'mat_views/services/check_matview_exists'
+require 'mat_views/admin/auth_bridge'
+require 'mat_views/admin/default_auth'
 
 ##
 # MatViews is a Rails engine that provides first-class support for
-# PostgreSQL materialized views in Rails applications.
+# PostgreSQL materialised views in Rails applications.
 #
 # Features include:
-# - Declarative definitions for materialized views
+# - Declarative definitions for materialised views
 # - Safe creation, refresh (regular, concurrent, swap), and deletion
 # - Background job integration (ActiveJob, Sidekiq, Resque)
 # - Tracking of run history and metrics
@@ -35,23 +40,25 @@ require 'mat_views/services/delete_view'
 #   end
 #
 # Once mounted, Rails apps can leverage MatViews services and jobs
-# to manage materialized views consistently.
+# to manage materialised views consistently.
 module MatViews
   class << self
     # Global configuration for MatViews
     # @return [MatViews::Configuration]
-    attr_accessor :configuration
+    attr_reader :configuration
 
     # Configure MatViews via block.
     #
     # Example:
     #   MatViews.configure do |config|
     #     config.job_adapter = :sidekiq
-    #     config.job_queue   = :materialized
+    #     config.job_queue   = :materialised
     #   end
     def configure
-      self.configuration ||= Configuration.new
+      @configuration ||= Configuration.new
       yield(configuration)
+
+      configuration.admin_ui[:row_count_strategy] ||= :none
     end
   end
 end

data/lib/tasks/helpers.rb

@@ -13,7 +13,7 @@ module MatViews
     # - Parsing boolean/flag-like arguments
     # - Confirmation prompts
     # - Enqueueing background jobs for create, refresh, and delete operations
-    # - Looking up materialized view definitions
+    # - Looking up materialised view definitions
     #
     # By extracting this logic, Rake tasks can remain clean and declarative.
     module Helpers
@@ -51,15 +51,15 @@ 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.
+      # Check if a materialised view exists in schema.
       # @param rel [String] relation name
       # @param schema [String] schema name
       # @return [Boolean]
@@ -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)
@@ -109,7 +110,7 @@ module MatViews
       # Otherwise, prompts user for confirmation and raises if declined.
       def confirm!(message, skip: false)
         if skip
-          logger.info("[mat_views] #{message} — confirmation skipped.")
+          logger.info("[mat_views] #{message} - confirmation skipped.")
           return
         end
 
@@ -124,32 +125,31 @@ module MatViews
 
       # Enqueue a CreateView job for given definition.
       #
-      # @param definition_id [Integer] MatViewDefinition ID
+      # @param mat_view_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(mat_view_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: [mat_view_definition_id, force, row_count_strategy]
         )
       end
 
       # Enqueue a RefreshView job for given definition.
       #
-      # @param definition_id [Integer] MatViewDefinition ID
+      # @param mat_view_definition_id [Integer] MatViewDefinition ID
       # @param row_count_strategy [Symbol] :estimated or :exact
       # @return [void]
       #
       # 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(mat_view_definition_id, row_count_strategy)
         MatViews::Jobs::Adapter.enqueue(
           MatViews::RefreshViewJob,
-          queue: q,
-          args: [definition_id, row_count_strategy]
+          queue: MatViews.configuration.job_queue || :default,
+          args: [mat_view_definition_id, row_count_strategy]
         )
       end
 
@@ -166,18 +166,18 @@ module MatViews
 
       # Enqueue a DeleteView job for given definition.
       #
-      # @param definition_id [Integer] MatViewDefinition ID
+      # @param mat_view_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.
+      # This method schedules a job to delete the materialised 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(mat_view_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: [mat_view_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|
-    raise 'mat_views:create_by_id requires a definition_id parameter' if args[:definition_id].to_s.strip.empty?
+  task :create_by_id, %i[mat_view_definition_id force row_count_strategy yes] => :environment do |_t, args|
+    raise 'mat_views:create_by_id requires a mat_view_definition_id parameter' if args[:mat_view_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
+    defn = MatViews::MatViewDefinition.find_by(id: args[:mat_view_definition_id])
+    raise "No MatViews::MatViewDefinition found for id=#{args[:mat_view_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|
+  desc 'Enqueue CREATE jobs for ALL defined materialised views'
+  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,26 +64,26 @@ 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'
-  task :refresh_by_id, %i[definition_id row_count_strategy yes] => :environment do |_t, args|
-    raise 'mat_views:refresh_by_id requires a definition_id parameter' if args[:definition_id].to_s.strip.empty?
+  task :refresh_by_id, %i[mat_view_definition_id row_count_strategy yes] => :environment do |_t, args|
+    raise 'mat_views:refresh_by_id requires a mat_view_definition_id parameter' if args[:mat_view_definition_id].to_s.strip.empty?
 
     rcs  = helpers.parse_row_count_strategy(args[:row_count_strategy])
     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
+    defn = MatViews::MatViewDefinition.find_by(id: args[:mat_view_definition_id])
+    raise "No MatViews::MatViewDefinition found for id=#{args[:mat_view_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'
+  desc 'Enqueue REFRESH jobs for ALL defined materialised views'
   task :refresh_all, %i[row_count_strategy yes] => :environment do |_t, args|
     rcs  = helpers.parse_row_count_strategy(args[:row_count_strategy])
     skip = helpers.skip_confirm?(args[:yes])
@@ -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|
-    raise 'mat_views:delete_by_id requires a definition_id parameter' if args[:definition_id].to_s.strip.empty?
+  task :delete_by_id, %i[mat_view_definition_id cascade row_count_strategy yes] => :environment do |_t, args|
+    raise 'mat_views:delete_by_id requires a mat_view_definition_id parameter' if args[:mat_view_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
+    defn = MatViews::MatViewDefinition.find_by(id: args[:mat_view_definition_id])
+    raise "No MatViews::MatViewDefinition found for id=#{args[:mat_view_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|
+  desc 'Enqueue DELETE jobs for ALL defined materialised views'
+  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