activerecord-materialized 0.1.0 → 0.2.0

data/lib/activerecord/materialized/aggregate_analysis.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -10,47 +9,36 @@ module ActiveRecord
     # so emptied partitions can be detected; everything else falls back to scoped
     # recompute, which is always correct.
     class AggregateAnalysis
-      extend T::Sig
-
       # One classified aggregate column from a view's projection.
       #
       # @api private
-      class Column < T::Struct
-        const :name, String
-        const :function, Symbol
-        const :attribute, T.nilable(String)
-        const :counts_rows, T::Boolean, default: false
+      Column = Data.define(:name, :function, :attribute, :counts_rows) do
+        def initialize(name:, function:, attribute: nil, counts_rows: false) = super
       end
 
-      sig { params(relation: ::ActiveRecord::Relation).void }
       def initialize(relation)
         @relation = relation
-        @aggregate_columns = T.let(nil, T.nilable(T::Array[Column]))
+        @aggregate_columns = nil
       end
 
-      sig { returns(T::Array[Column]) }
       def aggregate_columns
-        @aggregate_columns ||= T.unsafe(@relation).select_values.filter_map { |value| classify(value) }
+        @aggregate_columns ||= @relation.select_values.filter_map { |value| classify(value) }
       end
 
-      sig { returns(T::Boolean) }
       def delta_maintainable?
         single_table? && grouped? && !having? && distributive_aggregates? && aggregate_columns.any?(&:counts_rows)
       end
 
-      sig { returns(T::Boolean) }
       def distributive_aggregates?
         aggregate_columns.any? && aggregate_columns.all? { |column| distributive?(column) }
       end
 
-      sig { returns(T.nilable(Column)) }
       def row_count_column
         aggregate_columns.find(&:counts_rows)
       end
 
       private
 
-      sig { params(value: T.untyped).returns(T.nilable(Column)) }
       def classify(value)
         return nil unless value.is_a?(::Arel::Nodes::As)
 
@@ -66,7 +54,6 @@ module ActiveRecord
         end
       end
 
-      sig { params(name: String, node: T.untyped).returns(Column) }
       def count_column(name, node)
         return Column.new(name: name, function: :count_distinct, attribute: attribute_name(node)) if node.distinct
         return Column.new(name: name, function: :count_star, counts_rows: true) if star?(node)
@@ -75,7 +62,6 @@ module ActiveRecord
         Column.new(name: name, function: :count, attribute: attribute, counts_rows: not_null_column?(attribute))
       end
 
-      sig { params(column: Column).returns(T::Boolean) }
       def distributive?(column)
         case column.function
         # A SUM over a nullable column can be NULL, which a zero delta can't
@@ -87,45 +73,38 @@ module ActiveRecord
         end
       end
 
-      sig { params(node: T.untyped).returns(T.nilable(String)) }
       def attribute_name(node)
         inner = node.expressions.first
-        inner.is_a?(::Arel::Attributes::Attribute) ? T.unsafe(inner).name.to_s : nil
+        inner.is_a?(::Arel::Attributes::Attribute) ? inner.name.to_s : nil
       end
 
-      sig { params(node: T.untyped).returns(T::Boolean) }
       def star?(node)
         inner = node.expressions.first
         !!(inner.is_a?(::Arel::Nodes::SqlLiteral) && inner.to_s == "*")
       end
 
-      sig { params(value: ::Arel::Nodes::As).returns(String) }
       def alias_name(value)
-        right = T.unsafe(value).right
+        right = value.right
         right.respond_to?(:name) ? right.name.to_s : right.to_s
       end
 
-      sig { params(attribute: T.nilable(String)).returns(T::Boolean) }
       def not_null_column?(attribute)
         return false if attribute.nil?
 
-        column = T.unsafe(@relation).klass.columns_hash[attribute]
+        column = @relation.klass.columns_hash[attribute]
         !column.nil? && !column.null
       end
 
-      sig { returns(T::Boolean) }
       def single_table?
-        T.unsafe(@relation).joins_values.empty? && T.unsafe(@relation).from_clause.value.nil?
+        @relation.joins_values.empty? && @relation.from_clause.value.nil?
       end
 
-      sig { returns(T::Boolean) }
       def grouped?
-        T.unsafe(@relation).group_values.any?
+        @relation.group_values.any?
       end
 
-      sig { returns(T::Boolean) }
       def having?
-        !T.unsafe(@relation).having_clause.empty?
+        !@relation.having_clause.empty?
       end
     end
   end

data/lib/activerecord/materialized/async_refresher.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -8,9 +7,6 @@ module ActiveRecord
     # @api private
     class AsyncRefresher
       class << self
-        extend T::Sig
-
-        sig { params(view_class: ViewClass).void }
         def enqueue(view_class)
           interval = view_class.resolved_refresh_debounce
 
@@ -20,7 +16,6 @@ module ActiveRecord
           end
         end
 
-        sig { void }
         def flush!
           mutex.synchronize do
             cancel_timer_unlocked
@@ -28,12 +23,10 @@ module ActiveRecord
           end
         end
 
-        sig { returns(Integer) }
         def pending_count
           mutex.synchronize { pending.size }
         end
 
-        sig { void }
         def reset!
           mutex.synchronize do
             cancel_timer_unlocked
@@ -43,44 +36,43 @@ module ActiveRecord
 
         # When paused, refreshes accumulate and run only on an explicit flush! —
         # no background timer fires.
-        sig { params(value: T::Boolean).void }
-        def paused=(value)
-          @paused = T.let(value, T.nilable(T::Boolean))
-        end
+        attr_writer :paused
 
-        sig { returns(T::Boolean) }
         def paused?
-          @paused = T.let(@paused, T.nilable(T::Boolean))
           @paused || false
         end
 
         private
 
-        sig { returns(T::Hash[String, ViewClass]) }
         def pending
-          @pending ||= T.let({}, T.nilable(T::Hash[String, ViewClass]))
+          @pending ||= {}
         end
 
-        sig { returns(Mutex) }
         def mutex
-          @mutex ||= T.let(Mutex.new, T.nilable(Mutex))
+          @mutex ||= Mutex.new
         end
 
-        sig { params(interval: T.any(Integer, Float)).void }
         def schedule_unlocked(interval)
           cancel_timer_unlocked
           return if paused?
 
-          @timer_thread = T.let(
-            Thread.new do
-              sleep(interval) unless interval.zero?
-              mutex.synchronize { drain_pending_unlocked }
-            end,
-            T.nilable(Thread)
-          )
+          @timer_thread = Thread.new do
+            sleep(interval) unless interval.zero?
+            drain_on_pooled_connection
+          end
+        end
+
+        # The background drain runs `refresh!` (real DML) on a thread of our own, so it must lease a
+        # pooled connection and return it. `with_connection` checks one out for the block and releases
+        # it in an ensure — even if a refresh raises — so a burst of writes can't leak the pool dry.
+        # (The synchronous `flush!` path drains on the caller's already-managed thread, so it is left
+        # to that thread's connection lifecycle.)
+        def drain_on_pooled_connection
+          ::ActiveRecord::Base.connection_pool.with_connection do
+            mutex.synchronize { drain_pending_unlocked }
+          end
         end
 
-        sig { void }
         def cancel_timer_unlocked
           return unless @timer_thread&.alive?
 
@@ -88,7 +80,6 @@ module ActiveRecord
           @timer_thread = nil
         end
 
-        sig { void }
         def drain_pending_unlocked
           views = pending.values
           pending.clear

data/lib/activerecord/materialized/cache_table_schema.rb

@@ -1,67 +1,86 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
   module Materialized
-    # Infers a view's cache-table columns from its source relation and provisions the table.
+    # Provisions a view's cache table from its source relation. The per-column type
+    # inference lives in ColumnTypeInference; this module maps the inferred definitions
+    # onto create_table (and, via MigrationBuilder, a generated migration).
     #
     # @api private
     module CacheTableSchema
-      extend T::Sig
+      # An inferred cache-table column: name from the relation projection, a create_table
+      # column type, and — for a :decimal — the precision/scale that preserve value
+      # fidelity (a bare `decimal` is DECIMAL(10,0) on MySQL, which truncates).
+      ColumnDefinition = Data.define(:name, :type, :precision, :scale) do
+        def initialize(name:, type:, precision: nil, scale: nil) = super
 
-      # An inferred cache-table column: name from the relation projection, type
-      # one of :integer, :decimal, :boolean, :datetime, :string.
-      class ColumnDefinition < T::Struct
-        const :name, String
-        const :type, Symbol
+        # create_table options for this column (precision/scale for a decimal; none otherwise).
+        def options
+          { precision: precision, scale: scale }.compact
+        end
+
+        # The trailing arguments for a `t.<type> :<name>` migration line ("" when none).
+        def migration_arguments
+          options.map { |key, value| ", #{key}: #{value}" }.join
+        end
       end
 
+      # The partition-key index a cache table is built with: the GROUP BY / maintenance-key columns
+      # (unqualified to their cache-column names), unique when the key is the whole partition identity
+      # (a plain GROUP BY, one row per group). Incremental maintenance filters/deletes/re-selects by
+      # exactly these columns, so without this index every partition operation is a full cache scan.
+      #
+      # @api private
+      IndexDefinition = Data.define(:columns, :unique)
+
       module_function
 
-      sig { params(view_class: T.class_of(::ActiveRecord::Base), relation: ::ActiveRecord::Relation).void }
       def ensure_table!(view_class, relation)
         return if view_class.table_exists?
 
-        build_table!(view_class.connection, view_class.table_name, relation)
+        build_table!(view_class.connection, view_class.table_name, relation, index: index_definition(view_class))
         view_class.reset_column_information
       end
 
-      sig { params(view_class: T.class_of(::ActiveRecord::Base), table_name: String, relation: ::ActiveRecord::Relation).void }
       def create_table!(view_class, table_name, relation)
-        build_table!(view_class.connection, table_name, relation)
+        build_table!(view_class.connection, table_name, relation, index: index_definition(view_class))
+      end
+
+      # The partition-key index for a view, or nil for a non-grouped view (no maintenance key to index).
+      # A key derived purely from the GROUP BY is the partition identity, so the index is UNIQUE — which
+      # also structurally prevents duplicate partition rows under concurrent maintenance (see #95). An
+      # explicit +incremental_keys+ override may be coarser than the grouping, so that index is non-unique.
+      #
+      # @return [IndexDefinition, nil]
+      def index_definition(view_class)
+        keys = view_class.maintenance_key_columns
+        return nil if keys.empty?
+
+        columns = keys.map { |key| key.rpartition(".").last }
+        IndexDefinition.new(columns: columns, unique: view_class.incremental_key_columns.empty?)
       end
 
-      # The inferred MV columns (names from the projection, types from a one-row
-      # probe). Shared by table creation, migration generation, and drift checks.
-      sig { params(connection: Connection, relation: ::ActiveRecord::Relation).returns(T::Array[ColumnDefinition]) }
+      # The inferred MV columns. Names come from the query's projection (authoritative, via
+      # a zero-row probe); each column's type is inferred structurally from its projected
+      # node by ColumnTypeInference. Shared by table creation, migration generation, and
+      # drift checks.
       def column_definitions(connection, relation)
-        result = connection.exec_query(relation.limit(1).to_sql)
-        sample = result.rows.first
-        result.columns.each_with_index.map do |name, index|
-          ColumnDefinition.new(name: name, type: type_for_value(sample&.at(index)))
+        nodes = relation.select_values
+        connection.exec_query(relation.limit(0).to_sql).columns.each_with_index.map do |name, index|
+          ColumnTypeInference.definition_for(connection, relation, nodes[index], name)
         end
       end
 
-      sig { params(connection: Connection, table_name: String, relation: ::ActiveRecord::Relation).void }
-      def build_table!(connection, table_name, relation)
+      def build_table!(connection, table_name, relation, index: nil)
         definitions = column_definitions(connection, relation)
         connection.create_table(table_name) do |table|
-          definitions.each { |definition| T.unsafe(table).public_send(definition.type, definition.name) }
+          definitions.each do |definition|
+            table.public_send(definition.type, definition.name, **definition.options)
+          end
+          table.index(index.columns, unique: index.unique) if index
         end
       end
       private_class_method :build_table!
-
-      sig { params(value: T.untyped).returns(Symbol) }
-      def type_for_value(value)
-        case value
-        when Integer then :integer
-        when Float, BigDecimal then :decimal
-        when TrueClass, FalseClass then :boolean
-        when Time, Date, DateTime, ::ActiveSupport::TimeWithZone then :datetime
-        else :string
-        end
-      end
-      private_class_method :type_for_value
     end
   end
 end

data/lib/activerecord/materialized/change_source.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # The change sources a view can declare. `:callbacks` (the default) installs
+    # the built-in ActiveRecord commit-callback tracker on `depends_on` models;
+    # `:none` installs no callbacks and expects changes through the public
+    # ingestion API from an external adapter.
+    module ChangeSource
+      CALLBACKS = :callbacks
+      NONE = :none
+      NAMES = [CALLBACKS, NONE].freeze
+
+      # Validates and normalizes a change-source name, raising on an unknown one
+      # so a typo fails loudly at definition/configuration time instead of
+      # silently disabling all maintenance for the view.
+      def self.cast(source)
+        name = source.to_sym
+        return name if NAMES.include?(name)
+
+        raise ArgumentError, "Unknown change source #{source.inspect} (expected one of #{NAMES.inspect})"
+      end
+    end
+  end
+end

data/lib/activerecord/materialized/cold_read.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -8,14 +7,10 @@ module ActiveRecord
     # table aliased to the cache table name, so where/order/limit/count keep
     # working against the same column names.
     class ColdRead
-      extend T::Sig
-
-      sig { params(view_class: ViewClass).void }
       def initialize(view_class)
         @view_class = view_class
       end
 
-      sig { returns(T.untyped) }
       def scope
         case @view_class.resolved_cold_read_strategy
         when :read_through
@@ -33,25 +28,21 @@ module ActiveRecord
 
       private
 
-      sig { returns(T.untyped) }
       def unscoped
-        T.unsafe(@view_class).unscoped
+        @view_class.unscoped
       end
 
-      sig { returns(Arel::Nodes::SqlLiteral) }
       def source_derived_table
         Arel.sql("(#{@view_class.resolved_source.to_sql}) #{@view_class.quoted_table_name}")
       end
 
       # Provisions an empty cache table for column metadata — cheap DDL, no data.
-      sig { void }
       def ensure_skeleton!
         return if @view_class.table_exists?
 
         CacheTableSchema.ensure_table!(@view_class, @view_class.resolved_source)
       end
 
-      sig { returns(String) }
       def not_materialized_message
         "#{@view_class.name} is not materialized; run #{@view_class.name}.rebuild!(confirm: true)"
       end

data/lib/activerecord/materialized/column_type_inference.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Infers one cache-table column (a CacheTableSchema::ColumnDefinition) from a single
+    # projected node of a view's source relation, deriving from the aggregated/grouped
+    # SOURCE column so the cache mirrors the real data's constraints:
+    #   - a group key or plain projection takes its source column's declared type, and for
+    #     a decimal its exact precision/scale;
+    #   - MIN/MAX return a source value unchanged, so they mirror the source column too;
+    #   - SUM/AVG derive a wide DECIMAL from the aggregated column (a sum outgrows the
+    #     source's integer digits; an average adds fractional scale), or :float when the
+    #     source itself is a float;
+    #   - COUNT is an integer count.
+    # Deterministic and correct even when the source is empty (a sampled-row probe types
+    # everything :string). Used by CacheTableSchema to build tables, generate migrations,
+    # and check drift.
+    #
+    # @api private
+    module ColumnTypeInference
+      # Shorthand for the value type this module produces.
+      Definition = CacheTableSchema::ColumnDefinition
+
+      # DECIMAL precision for a SUM/AVG column, whose result exceeds the aggregated source
+      # column's own budget — a sum grows past its integer-digit range, an average past its
+      # scale. Wide enough for any realistic aggregate and within MySQL's DECIMAL(65) cap.
+      AGGREGATE_PRECISION = 38
+
+      # Extra fractional digits an average introduces beyond its source column's scale
+      # (matching MySQL's own AVG widening). A materialized average is exact for a
+      # terminating result; a non-terminating one (e.g. PostgreSQL AVG of 1, 2, 2) is
+      # rounded at this scale — inherent to storing a division result in a fixed column.
+      AVG_SCALE_HEADROOM = 4
+
+      # Fractional scale for a SUM/AVG over an unscaled numeric source (one whose own
+      # scale the schema does not record), so its fractional part is not truncated to zero.
+      DEFAULT_DECIMAL_SCALE = 6
+
+      # Largest DECIMAL scale every target engine accepts (MySQL caps at 30); a derived
+      # scale is clamped to it so table creation never fails on an out-of-range scale.
+      MAX_DECIMAL_SCALE = 30
+
+      # Source column types that map directly to a create_table column builder. A type
+      # outside this set (e.g. a PostgreSQL enum, whose declared type is the enum's own
+      # name) has no `t.<type>` shorthand, so it degrades to :string rather than crashing
+      # table creation.
+      SAFE_TYPES = %i[integer bigint decimal float boolean string text binary datetime date time].freeze
+
+      module_function
+
+      # The cache column for one projected node — an Arel aggregate, a plain attribute, an
+      # aliased wrapper of either, or a bare Symbol resolved against the source schema.
+      # Falls back to a :string column when a node can't be classified.
+      def definition_for(connection, relation, node, name)
+        node = node.left if node.is_a?(::Arel::Nodes::As)
+        aggregate_column(connection, node, name) ||
+          attribute_column(connection, node, name) ||
+          named_column(relation, node, name) ||
+          Definition.new(name: name, type: :string)
+      end
+
+      # A column for an Arel aggregate function, or nil when the node is not one (so the
+      # caller falls through to plain-attribute / named-column handling).
+      def aggregate_column(connection, node, name)
+        case node
+        when ::Arel::Nodes::Count then Definition.new(name: name, type: :integer)
+        when ::Arel::Nodes::Sum then sum_avg_column(connection, node, name, 0)
+        when ::Arel::Nodes::Avg then sum_avg_column(connection, node, name, AVG_SCALE_HEADROOM)
+        when ::Arel::Nodes::Min, ::Arel::Nodes::Max then min_max_column(connection, node, name)
+        end
+      end
+
+      # SUM/AVG over a float source stays :float — a fixed DECIMAL scale would truncate it.
+      # Otherwise a wide DECIMAL keeping the source's fractional scale plus AVG's headroom
+      # (an integer or unresolved source contributes scale 0, so a sum stays exact).
+      def sum_avg_column(connection, node, name, extra_scale)
+        column = aggregate_source_column(connection, node)
+        return Definition.new(name: name, type: :float) if column&.type == :float
+
+        decimal_aggregate(name, source_scale(column) + extra_scale)
+      end
+
+      # A wide DECIMAL for a SUM/AVG result, with the scale clamped to what every engine
+      # accepts (MAX_DECIMAL_SCALE, always <= the precision) so table creation can't fail
+      # on an out-of-range scale.
+      def decimal_aggregate(name, scale)
+        Definition.new(
+          name: name, type: :decimal, precision: AGGREGATE_PRECISION, scale: scale.clamp(0, MAX_DECIMAL_SCALE)
+        )
+      end
+
+      # MIN/MAX return one of the source values unchanged, so the column mirrors the
+      # aggregated attribute exactly; a wide integer-scale decimal when it can't be resolved.
+      def min_max_column(connection, node, name)
+        attribute_column(connection, node.expressions.first, name) || decimal_aggregate(name, 0)
+      end
+
+      # The live source Column an aggregate is computed over (e.g. amount for SUM(amount)),
+      # or nil for COUNT(*) or an aggregate not over a plain attribute.
+      def aggregate_source_column(connection, node)
+        inner = node.expressions.first
+        inner.is_a?(::Arel::Attributes::Attribute) ? source_column(connection, inner) : nil
+      end
+
+      # The fractional scale to carry from an aggregate's source column: an integer or
+      # unresolved source contributes 0 (a sum stays whole); a decimal contributes its own
+      # scale, or DEFAULT_DECIMAL_SCALE for an unscaled numeric whose scale is unknown.
+      def source_scale(column)
+        return 0 unless column&.type == :decimal
+
+        column.scale || DEFAULT_DECIMAL_SCALE
+      end
+
+      # A column mirroring the source column an Arel attribute names, read from the live
+      # schema so a JOINED group key (e.g. authors.country) resolves too. nil when the node
+      # is not an attribute or its table/column can't be found.
+      def attribute_column(connection, node, name)
+        return nil unless node.is_a?(::Arel::Attributes::Attribute)
+
+        column = source_column(connection, node)
+        column ? column_from_source(column, name) : nil
+      end
+
+      # A column projected directly from the base table — a bare Symbol group key
+      # (`group(:region).select(:region, ...)`) or an implicit SELECT * (no projection
+      # node, so `node` is nil) — resolved against the source model's own schema. A
+      # raw-SQL/String or computed projection is NOT resolved this way: it may name a
+      # JOINED column that merely collides with a base column, so it falls through to
+      # :string rather than risk typing it from the wrong table.
+      def named_column(relation, node, name)
+        return nil unless node.nil? || node.is_a?(::Symbol)
+
+        column = relation.klass.columns_hash[name]
+        column ? column_from_source(column, name) : nil
+      end
+
+      # Map a live source Column to a cache Definition: an allowlisted create_table type
+      # (see SAFE_TYPES), carrying a decimal's exact precision/scale so the cache preserves
+      # the source column's value fidelity.
+      def column_from_source(column, name)
+        type = SAFE_TYPES.include?(column.type) ? column.type : :string
+        return Definition.new(name: name, type: type) unless type == :decimal
+
+        Definition.new(name: name, type: :decimal, precision: column.precision, scale: column.scale)
+      end
+
+      # The live source Column an Arel attribute names, or nil when its table/column can't be found.
+      def source_column(connection, node)
+        columns = connection.columns(source_relation_name(node.relation))
+        columns.find { |candidate| candidate.name == node.name.to_s }
+      rescue ::ActiveRecord::StatementInvalid
+        nil
+      end
+
+      # The real table name an Arel relation refers to, unwrapping a TableAlias (e.g. a self-join
+      # `Model.arel_table.alias("t2")`) to its underlying table — so an aliased attribute types against
+      # the real column instead of failing to resolve against the alias (which is not a real relation).
+      def source_relation_name(relation)
+        relation.is_a?(::Arel::Nodes::TableAlias) ? relation.relation.name : relation.name
+      end
+
+      private_class_method :aggregate_column, :sum_avg_column, :decimal_aggregate, :min_max_column,
+                           :aggregate_source_column, :source_scale, :attribute_column, :named_column,
+                           :column_from_source, :source_column, :source_relation_name
+    end
+  end
+end

data/lib/activerecord/materialized/configurable_table_name.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ActiveRecord
+  module Materialized
+    # Dynamic table-name resolution shared by the gem's internal AR models (metadata, partition,
+    # write-outbox). The default name is re-read from its configured source on every access, so a host
+    # app can rename the table via {Materialized.configure}; a test or app can still pin an explicit
+    # name with +self.table_name = "x"+, which then wins. Factored out of the three models so the
+    # order-sensitive idiom lives in one place.
+    #
+    # @api private
+    module ConfigurableTableName
+      extend ActiveSupport::Concern
+
+      included do
+        # A class_attribute (not a bare class-instance var) so a subclass inherits the resolver and
+        # resolves the default instead of raising NoMethodError on +table_name+.
+        class_attribute :table_name_resolver, instance_accessor: false
+      end
+
+      class_methods do
+        # Declare how the default table name is resolved. The +resolver+ block is called on each
+        # {table_name} read (dynamic), unless an explicit name was assigned via +self.table_name=+.
+        #
+        # @yieldreturn [String] the currently-configured table name
+        def configurable_table_name(&resolver)
+          self.table_name_resolver = resolver
+          # Seed ActiveRecord's internal @table_name once through its real setter, before the reader
+          # below shadows it, so any internal that reads the raw ivar sees a value. (arel_table /
+          # quoted_table_name are nilled by the setter and rebuild lazily through the overridden reader.)
+          self.table_name = table_name_resolver.call
+          @table_name_override = nil
+
+          define_singleton_method(:table_name) do
+            override = @table_name_override
+            override.nil? ? table_name_resolver.call : override
+          end
+          define_singleton_method(:table_name=) { |name| @table_name_override = name }
+        end
+      end
+    end
+  end
+end