activerecord-materialized 0.1.0 → 0.2.0

data/lib/activerecord/materialized/dependency_registry.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -8,49 +7,52 @@ module ActiveRecord
     # @api private
     class DependencyRegistry
       class << self
-        extend T::Sig
-
-        sig do
-          params(
-            view_class: ViewClass,
-            tables: T.any(
-              Symbol,
-              String,
-              T.class_of(::ActiveRecord::Base),
-              T::Array[T.any(Symbol, String, T.class_of(::ActiveRecord::Base))]
-            )
-          ).void
-        end
         def register(view_class, tables)
           normalized = Array(tables).flat_map { |entry| normalize_dependency(entry) }
-          T.unsafe(view_class).instance_variable_set(:@dependency_tables, normalized)
+          view_class.instance_variable_set(:@dependency_tables, normalized)
 
           normalized.each do |table|
-            bucket = T.cast(dependency_index[table], T::Array[ViewClass])
+            bucket = dependency_index[table]
             bucket << view_class unless bucket.include?(view_class)
-            subscribe_source_table!(table)
+            subscribe_source_table!(table, view_class)
           end
         end
 
-        sig { params(table: String).returns(T::Array[ViewClass]) }
         def views_for_table(table)
-          T.must(dependency_index[normalize_table(table)])
+          dependency_index[normalize_table(table)]
         end
 
-        sig { params(change: WriteChange).void }
-        def publish_write_change!(change)
+        # Records a committed write and schedules refresh for the affected views.
+        # `source` identifies the publisher so no view is maintained by two sources:
+        # a callback publish (`:callbacks`) drives only callback-backed views, and an
+        # explicit ingestion-API publish (`nil`) drives only externally-fed views.
+        def publish_write_change!(change, source: nil)
           affected_views([change.table_name]).each do |view|
+            next unless delivers_to?(view, source)
+
             view.record_write_change!(change)
             RefreshScheduler.schedule(view)
           end
         end
 
-        sig { params(tables: T::Array[String]).void }
+        # Coarse ingestion signal: something changed in these tables but the caller
+        # cannot describe the individual write. Enqueues a full recompute (the only
+        # correct scope without a partition key) and schedules it — idempotent, so
+        # safe to call repeatedly and after callback-skipping bulk loads.
         def mark_dirty_for_tables!(tables)
-          affected_views(tables).each(&:mark_dependencies_changed!)
+          affected_views(tables).each do |view|
+            MaintenanceStore.new(view).merge!(MaintenanceDelta.full_partition)
+            RefreshScheduler.schedule(view)
+          end
+        end
+
+        # (Re)installs the built-in callback tracker for a view's already-declared
+        # dependency tables. Invoked by `change_source :callbacks` so opting in works
+        # whether it precedes or follows `depends_on`.
+        def install_callbacks_for(view_class)
+          view_class.dependency_tables.each { |table| subscribe_source_table!(table, view_class) }
         end
 
-        sig { void }
         def reset!
           @dependency_index = Hash.new { |hash, key| hash[key] = [] }
           ActiveRecord::Materialized::DependencyTrackable.reset!
@@ -58,15 +60,19 @@ module ActiveRecord
 
         private
 
-        sig { returns(T::Hash[String, T::Array[ViewClass]]) }
         def dependency_index
-          @dependency_index ||= T.let(
-            Hash.new { |hash, key| hash[key] = [] },
-            T.nilable(T::Hash[String, T::Array[ViewClass]])
-          )
+          @dependency_index ||= Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        # A callback publish reaches callback-backed views; any other (external)
+        # publish reaches views that are NOT callback-backed. This keeps each view
+        # tied to a single source, so the additive summary-delta path is never
+        # applied twice for one write.
+        def delivers_to?(view, source)
+          callback_backed = view.resolved_change_source == ChangeSource::CALLBACKS
+          source == ChangeSource::CALLBACKS ? callback_backed : !callback_backed
         end
 
-        sig { params(tables: T::Array[String]).returns(T::Array[ViewClass]) }
         def affected_views(tables)
           Array(tables).flat_map do |table|
             next [] if skip_table?(table)
@@ -75,7 +81,6 @@ module ActiveRecord
           end.uniq
         end
 
-        sig { params(entry: T.untyped).returns(T::Array[String]) }
         def normalize_dependency(entry)
           if entry.is_a?(Class) && entry < ::ActiveRecord::Base
             TableModelRegistry.register(entry)
@@ -85,18 +90,21 @@ module ActiveRecord
           [normalize_table(entry)]
         end
 
-        sig { params(table: String).void }
-        def subscribe_source_table!(table)
+        # Installs the built-in commit-callback tracker for a table's model, unless
+        # the view opts out of callbacks (`change_source :none` / a `:none` global
+        # default) — in which case the dependency is still indexed for scoping and
+        # metadata, but its writes are expected to arrive via the ingestion API.
+        def subscribe_source_table!(table, view_class)
+          return unless view_class.resolved_change_source == ChangeSource::CALLBACKS
+
           model = TableModelRegistry.resolve(table)
           ActiveRecord::Materialized::DependencyTrackable.subscribe(model) if model
         end
 
-        sig { params(table: T.any(Symbol, String)).returns(String) }
         def normalize_table(table)
           ::ActiveSupport::Inflector.underscore(table.to_s.delete_prefix(":"))
         end
 
-        sig { params(table: T.any(Symbol, String)).returns(T::Boolean) }
         def skip_table?(table)
           name = normalize_table(table)
           name.start_with?("mv_") || name == ::ActiveRecord::Materialized.metadata_table_name

data/lib/activerecord/materialized/dependency_trackable.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,14 +6,9 @@ module ActiveRecord
     #
     # @api private
     module DependencyTrackable
-      extend T::Sig
-
       TRACKABLE_FLAG = :@ar_materialized_dependency_trackable
 
       class << self
-        extend T::Sig
-
-        sig { params(model_class: T.class_of(::ActiveRecord::Base)).void }
         def subscribe(model_class)
           return if model_class.instance_variable_get(TRACKABLE_FLAG)
 
@@ -23,24 +17,23 @@ module ActiveRecord
         end
 
         # Invoked from the model commit callbacks; `record` is the committed instance.
-        sig { params(record: ::ActiveRecord::Base, operation: WriteChange::Operation).void }
+        # Publishes as the `:callbacks` source so views fed by another change source
+        # are not maintained twice.
         def publish(record, operation)
-          DependencyRegistry.publish_write_change!(WriteChange.from_record(record, operation))
+          DependencyRegistry.publish_write_change!(WriteChange.from_record(record, operation), source: :callbacks)
         end
 
-        sig { void }
         def reset!
           nil
         end
 
         private
 
-        sig { params(model_class: T.class_of(::ActiveRecord::Base)).void }
         def install_callbacks!(model_class)
-          model = T.unsafe(model_class)
-          model.after_create_commit { DependencyTrackable.publish(T.unsafe(self), :create) }
-          model.after_update_commit { DependencyTrackable.publish(T.unsafe(self), :update) }
-          model.after_destroy_commit { DependencyTrackable.publish(T.unsafe(self), :destroy) }
+          model = model_class
+          model.after_create_commit { DependencyTrackable.publish(self, :create) }
+          model.after_update_commit { DependencyTrackable.publish(self, :update) }
+          model.after_destroy_commit { DependencyTrackable.publish(self, :destroy) }
         end
       end
     end

data/lib/activerecord/materialized/incremental_maintainer.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,51 +6,69 @@ module ActiveRecord
     #
     # @api private
     class IncrementalMaintainer
-      extend T::Sig
-
-      sig { params(view_class: ViewClass).void }
       def initialize(view_class)
         @view_class = view_class
       end
 
-      sig { params(_connection: Connection, _table_name: String).returns(Integer) }
       def maintain!(_connection, _table_name)
         delta = maintenance_store.consume_pending_delta!
-        relation = resolve_maintenance_relation(delta)
+        return view_class.unscoped.count if delta.nil? # another cross-process cycle consumed it — no-op
+
+        apply_delta!(delta)
+      end
+
+      private
+
+      attr_reader :view_class
+
+      def apply_delta!(delta)
+        # A widen (full_partition) on a warm view is a full recompute — the same scan as rebuild!, so
+        # route it through the atomic build-and-swap instead of an in-place delete_all + re-insert. That
+        # keeps readers on the old snapshot until an instant rename, rather than exposing an empty/locked
+        # table mid-recompute. (A cold view can't reach here with full_partition: Refresher#maintainable?
+        # declines it, #120. So this branch is always the warm full-recompute case.)
+        return recompute_all! if delta.full_partition?
+
+        apply_scoped_delta!(delta)
+      end
+
+      def recompute_all!
+        RelationCacheWriter.new(view_class).atomic_swap!(full_source_relation)
+      end
+
+      def apply_scoped_delta!(delta)
+        partition_state = PartitionState.new(view_class)
+        cold_scoped = !view_class.materialized?
+        # Capture the fresh-set epoch BEFORE the source read, so a widen committing during the read
+        # advances the epoch and leaves this populate's mark un-served (the populate-vs-widen race, #120).
+        generation = partition_state.current_generation if cold_scoped
 
         row_count = RelationCacheWriter.new(view_class).replace_partitions!(
-          relation,
-          key_tuples: delta.key_tuples,
-          full_partition: delta.full_partition?
+          scoped_source_relation(delta.key_tuples),
+          key_tuples: delta.key_tuples
         )
 
-        # On a cold view the maintained partitions are now fresh.
-        unless delta.full_partition? || view_class.materialized?
-          PartitionState.new(view_class).mark_fresh!(delta.key_tuples)
-        end
+        # On a cold view the maintained partitions are now fresh, stamped with the captured epoch.
+        partition_state.mark_fresh!(delta.key_tuples, generation: generation) if cold_scoped
 
         row_count
       end
 
-      private
-
-      sig { returns(ViewClass) }
-      attr_reader :view_class
-
-      sig { returns(MaintenanceStore) }
       def maintenance_store
         MaintenanceStore.new(view_class)
       end
 
-      sig { params(delta: MaintenanceDelta).returns(::ActiveRecord::Relation) }
-      def resolve_maintenance_relation(delta)
-        if view_class.incremental_source_override?
-          view_class.resolved_incremental_source
-        elsif delta.full_partition?
-          view_class.resolved_source
-        else
-          view_class.view_definition.partition_scope(delta.key_tuples)
-        end
+      # The whole-view source for a full recompute (the incremental override wins when configured).
+      def full_source_relation
+        view_class.incremental_source_override? ? view_class.resolved_incremental_source : view_class.resolved_source
+      end
+
+      # The source restricted to the affected partitions (the incremental override wins when configured;
+      # it is already the maintainable relation, so it is not re-scoped here).
+      def scoped_source_relation(key_tuples)
+        return view_class.resolved_incremental_source if view_class.incremental_source_override?
+
+        view_class.view_definition.partition_scope(key_tuples)
       end
     end
   end

data/lib/activerecord/materialized/incremental_refresh.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Runs one incremental-maintenance pass for a view, choosing the summary-delta
+    # or scoped-recompute path from the pending maintenance and annotating the
+    # refresh instrumentation payload with the mode and partitions it touched.
+    #
+    # @api private
+    class IncrementalRefresh
+      def initialize(view_class, payload)
+        @view_class = view_class
+        @payload = payload
+      end
+
+      def call
+        ensure_cache_table!
+        store = MaintenanceStore.new(@view_class)
+        pending = store.pending
+        @payload[:mode] = mode(pending)
+        @payload[:partition_count] = partition_count(pending)
+        apply!(store, pending)
+      end
+
+      private
+
+      def apply!(store, pending)
+        if pending.is_a?(SummaryDelta)
+          # Consume+apply the additive delta under a row lock so concurrent cross-process cycles
+          # can't apply it twice; a loser finds an empty payload and no-ops. The row count is read
+          # after the lock releases (keeping the full-table COUNT out of the critical section) and
+          # reflects the cache's true total for winner and loser alike — never 0, which would
+          # clobber a populated view's row_count. The scoped path below serializes its own consume
+          # (MaintenanceStore#consume_pending_delta! takes the same row lock, #95), so a concurrent
+          # cross-process double-run recomputes a partition once rather than duplicating its rows.
+          store.with_consumed_summary_delta { |delta| DeltaMaintainer.new(@view_class).apply!(delta) }
+          return @view_class.unscoped.count
+        end
+
+        IncrementalMaintainer.new(@view_class).maintain!(@view_class.connection, @view_class.table_name)
+      end
+
+      def mode(pending)
+        pending.is_a?(SummaryDelta) ? :summary_delta : :scoped_recompute
+      end
+
+      # Partitions this pass recomputes; nil when it widened to a full recompute.
+      def partition_count(pending)
+        return pending.tracked_partition_count if pending.is_a?(SummaryDelta)
+        return nil unless pending.is_a?(MaintenanceDelta)
+
+        pending.full_partition? ? nil : pending.key_tuples.size
+      end
+
+      # Cheap DDL so partition maintenance has somewhere to write — never a populate.
+      def ensure_cache_table!
+        return if @view_class.table_exists?
+
+        CacheTableSchema.ensure_table!(@view_class, @view_class.resolved_source)
+      end
+    end
+  end
+end

data/lib/activerecord/materialized/instrumentation.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Materialized
+    # Emits `ActiveSupport::Notifications` events at the read / refresh /
+    # maintenance lifecycle points so adopters can wire freshness and behavior
+    # SLIs to any APM / StatsD / OpenTelemetry backend without the gem taking a
+    # dependency on a specific telemetry vendor.
+    #
+    # The event names and payload keys documented here are a stable contract —
+    # subscribe with {https://api.rubyonrails.org/classes/ActiveSupport/Notifications.html
+    # ActiveSupport::Notifications}:
+    #
+    #   ActiveSupport::Notifications.subscribe("read.active_record_materialized") do |event|
+    #     StatsD.increment("mv.read.#{event.payload[:source]}", tags: ["view:#{event.payload[:view]}"])
+    #   end
+    #
+    # Events:
+    #
+    # * +read.active_record_materialized+ — one per routed read. Payload:
+    #   +:view+ (the view class), +:source+ (+:cache+, +:read_through+,
+    #   +:serve_stale+, or +:raise+), +:staleness+ (seconds since the last
+    #   successful refresh, or +nil+ when never refreshed).
+    # * +refresh.active_record_materialized+ — one per +refresh!+/+rebuild!+,
+    #   timed. Payload: +:view+, +:operation+ (+:incremental+ or +:rebuild+),
+    #   +:mode+ (+:summary_delta+, +:scoped_recompute+, or +:full+),
+    #   +:partition_count+ (partitions recomputed, or +nil+ for a full pass),
+    #   +:row_count+, +:skipped+, and — on failure — the standard
+    #   +:exception+/+:exception_object+ keys set by +ActiveSupport::Notifications+.
+    # * +maintenance.active_record_materialized+ — one per dependency write that
+    #   records pending maintenance. Payload: +:view+, +:table+, +:operation+
+    #   (+:create+/+:update+/+:destroy+), +:path+ (+:summary_delta+ or
+    #   +:scoped_recompute+), +:scope+ (+:scoped+, or +:full+ when the write
+    #   widened to a full recompute because its partition key could not be
+    #   derived), +:partition_count+ (distinct partitions scoped, 0 on widen).
+    # * +reconcile.active_record_materialized+ — one per {Reconciler} run. Payload:
+    #   +:view+, +:mode+ (the drift-check depth), +:repaired_partition_count+
+    #   (partitions found divergent and repaired with scoped maintenance), +:deferred+
+    #   (+true+ when a concurrent refresh deferred the run to the next tick).
+    module Instrumentation
+      READ = "read.active_record_materialized"
+      REFRESH = "refresh.active_record_materialized"
+      MAINTENANCE = "maintenance.active_record_materialized"
+      RECONCILE = "reconcile.active_record_materialized"
+
+      class << self
+        # Fired once per routed read. The staleness lookup costs a metadata read,
+        # so it is skipped entirely unless a subscriber is attached.
+        def read(view_class, source:)
+          return unless ::ActiveSupport::Notifications.notifier.listening?(READ)
+
+          ::ActiveSupport::Notifications.instrument(
+            READ,
+            view: view_class, source: source, staleness: staleness_for(view_class)
+          )
+        end
+
+        # Wraps a refresh/rebuild so the event carries its wall-clock duration and
+        # any raised exception. The block runs the refresh and returns its
+        # {RefreshResult}; the row count and skipped flag are read back from it,
+        # while the block annotates the payload with the +:mode+ and
+        # +:partition_count+ it can only know mid-flight.
+        def refresh(view_class, operation:, &block)
+          ::ActiveSupport::Notifications.instrument(REFRESH, view: view_class, operation: operation) do |payload|
+            result = yield(payload)
+            payload[:row_count] = result.row_count
+            payload[:skipped] = result.skipped
+            result
+          end
+        end
+
+        # Fired once per dependency write that records pending maintenance.
+        def maintenance(view_class, change:, path:, scope:, partition_count:)
+          ::ActiveSupport::Notifications.instrument(
+            MAINTENANCE,
+            view: view_class, table: change.table_name, operation: change.operation.to_sym,
+            path: path, scope: scope, partition_count: partition_count
+          )
+        end
+
+        # Fired once per {Reconciler} run — after it verifies and (if needed) repairs
+        # via scoped maintenance — carrying the run's mode, repaired count, and defer flag.
+        def reconcile(view_class, mode:, repaired_partition_count:, deferred:)
+          ::ActiveSupport::Notifications.instrument(
+            RECONCILE,
+            view: view_class, mode: mode,
+            repaired_partition_count: repaired_partition_count, deferred: deferred
+          )
+        end
+
+        private
+
+        def staleness_for(view_class)
+          last_refreshed_at = view_class.metadata.last_refreshed_at
+          return nil if last_refreshed_at.nil?
+
+          (Metadata::Timestamps.current.to_time - last_refreshed_at.to_time).to_f
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/materialized/maintenance_delta.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,46 +6,34 @@ module ActiveRecord
     #
     # @api private
     class MaintenanceDelta
-      extend T::Sig
+      SCOPED = :scoped
+      FULL = :full_partition
 
-      SCOPED = T.let(:scoped, Symbol)
-      FULL = T.let(:full_partition, Symbol)
+      attr_reader :scope, :key_tuples
 
-      sig { returns(Symbol) }
-      attr_reader :scope
-
-      sig { returns(T::Array[T::Array[String]]) }
-      attr_reader :key_tuples
-
-      sig { params(scope: Symbol, key_tuples: T::Array[T::Array[String]]).void }
       def initialize(scope:, key_tuples: [])
         @scope = scope
         @key_tuples = key_tuples
       end
 
-      sig { params(key_tuples: T::Array[T::Array[String]]).returns(MaintenanceDelta) }
       def self.scoped(key_tuples)
         new(scope: SCOPED, key_tuples: key_tuples)
       end
 
-      sig { returns(MaintenanceDelta) }
       def self.full_partition
         new(scope: FULL)
       end
 
-      sig { returns(T::Boolean) }
       def full_partition?
         scope == FULL
       end
 
       # How many distinct partitions this pending maintenance tracks. A
       # full-partition recompute tracks none — it is already the collapsed form.
-      sig { returns(Integer) }
       def tracked_partition_count
         full_partition? ? 0 : key_tuples.size
       end
 
-      sig { params(other: MaintenanceDelta).returns(MaintenanceDelta) }
       def merge(other)
         return other if other.full_partition?
         return self if full_partition?
@@ -55,7 +42,6 @@ module ActiveRecord
         self.class.scoped(combined)
       end
 
-      sig { returns(T::Hash[String, T.untyped]) }
       def serialize
         {
           "scope" => scope.to_s,
@@ -63,7 +49,6 @@ module ActiveRecord
         }
       end
 
-      sig { params(payload: T.nilable(T::Hash[String, T.untyped])).returns(T.nilable(MaintenanceDelta)) }
       def self.deserialize(payload)
         return nil if payload.blank?
 
@@ -73,7 +58,7 @@ module ActiveRecord
         if scope_name == FULL
           full_partition
         else
-          tuples = T.cast(payload["key_tuples"], T.nilable(T::Array[T::Array[String]])) || []
+          tuples = payload["key_tuples"] || []
           scoped(tuples)
         end
       end

data/lib/activerecord/materialized/maintenance_delta_builder.rb

@@ -1,4 +1,3 @@
-# typed: strict
 # frozen_string_literal: true
 
 module ActiveRecord
@@ -7,25 +6,25 @@ module ActiveRecord
     #
     # @api private
     class MaintenanceDeltaBuilder
-      extend T::Sig
-
-      sig { params(change: WriteChange, key_columns: T::Array[String]).void }
-      def initialize(change, key_columns)
+      def initialize(change, key_columns, resolver: nil)
         @change = change
         @key_columns = key_columns
+        @resolver = resolver
       end
 
-      sig { returns(MaintenanceDelta) }
       def build
         return MaintenanceDelta.full_partition if @key_columns.empty?
 
-        tuples = extract_tuples
+        # A resolver is an explicit per-table mapping, so it is authoritative for
+        # that table's writes (it maps to the group key wherever it lives, even if
+        # the written row happens to carry a same-named column); otherwise the key
+        # comes from the written row's own payload.
+        tuples = @resolver ? resolved_tuples : extract_tuples
         tuples.empty? ? MaintenanceDelta.full_partition : MaintenanceDelta.scoped(tuples.uniq)
       end
 
       private
 
-      sig { returns(T::Array[T::Array[T.untyped]]) }
       def extract_tuples
         snapshots = case @change.operation.to_sym
                     when :create then [@change.after]
@@ -33,29 +32,62 @@ module ActiveRecord
                     when :update then [@change.before, @change.after]
                     else []
                     end
-        snapshots.filter_map { |attributes| key_tuple(attributes) }.uniq
+        tuples = snapshots.map { |attributes| key_tuple(attributes) }
+        # An update touches two partitions (old + new), a create/destroy one. If ANY affected snapshot
+        # can't yield its partition key — e.g. a non-FULL CDC before- or after-image with only the
+        # primary key — we can't identify every affected partition (a partial after-image can't even
+        # rule out a move), so return no tuples and let +build+ widen to a full recompute rather than
+        # under-scope to only the derivable side (leaving the other partition stale). +build+
+        # de-duplicates the tuples it scopes, so no +uniq+ here.
+        return [] if tuples.any?(&:nil?)
+
+        tuples
+      end
+
+      # Partition key tuple(s) from the configured resolver, or [] (=> full
+      # recompute) when none is set or it yields nothing.
+      def resolved_tuples
+        resolver = @resolver
+        return [] if resolver.nil?
+
+        normalize_keys(resolver.call(@change))
+      end
+
+      # Coerces a resolver's return into partition-key tuples, using the group key's
+      # arity to tell a single composite tuple from a list of tuples. A nil/empty
+      # return widens (=> full recompute); a returned nil value is a real key (the
+      # NULL partition), so it is kept rather than dropped.
+      def normalize_keys(result)
+        return [] if result.nil?
+
+        @key_columns.one? ? Array(result).zip : composite_tuples(result)
+      end
+
+      # A composite key expects a tuple or an array of tuples; anything else (a bare
+      # scalar, nil, empty) can't be scoped, so it widens rather than crashing.
+      def composite_tuples(result)
+        return [] unless result.is_a?(Array) && result.any?
+
+        result.first.is_a?(Array) ? result : [result]
       end
 
-      sig { params(attributes: T::Hash[String, T.untyped]).returns(T::Boolean) }
       def keys_present?(attributes)
         @key_columns.all? do |column|
-          attributes.key?(column) || T.unsafe(attributes).key?(column.to_sym)
+          attributes.key?(column) || attributes.key?(column.to_sym)
         end
       end
 
-      sig { params(attributes: T::Hash[String, T.untyped]).returns(T.nilable(T::Array[T.untyped])) }
       def key_tuple(attributes)
         return nil unless keys_present?(attributes)
 
         @key_columns.map { |column| attribute_value(attributes, column) }
       end
 
-      sig { params(attributes: T::Hash[String, T.untyped], column: String).returns(T.untyped) }
       def attribute_value(attributes, column)
         # Look up by presence so falsey group-key values map to their partition.
         return attributes[column] if attributes.key?(column)
 
-        T.unsafe(attributes)[column.to_sym]
+        attributes[column.to_sym]
       end
     end
   end