paper_trail_diff 0.13.1 → 0.14.0

data/lib/paper_trail_diff/scope_ranking.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module PaperTrailDiff
+  # The order, offset and limit by which a scope picks its members from the
+  # records that meet its conditions, as the database would rank them. It is
+  # read only when the order is total and every key compares in Ruby as SQL
+  # compares it; otherwise build returns nil and the caller keeps its slower
+  # path.
+  class ScopeRanking
+    DIRECTIONS = { 'Arel::Nodes::Ascending' => false, 'Arel::Nodes::Descending' => true }.freeze
+    ATTRIBUTE = 'Arel::Attributes::Attribute'
+    ENUM_TYPE = 'ActiveRecord::Enum::EnumType'
+    # Integers, booleans and dates sort alike everywhere. Strings follow a
+    # collation, so they are not read.
+    ORDER_TYPES = %w[ActiveModel::Type::Integer ActiveModel::Type::Boolean
+                     ActiveModel::Type::Date].freeze
+    # Times sort alike only at the precision both the column and history
+    # keep. A time of day is not read: in memory it keeps the date it was
+    # given, which the database drops.
+    DATETIME_TYPE = 'ActiveModel::Type::DateTime'
+    # Where each adapter sorts NULL in an ascending order by default; a
+    # descending order reverses it. Another adapter's ranking is not read.
+    NULLS_LAST = { 'postgresql' => true, 'sqlite3' => false, 'mysql2' => false,
+                   'trilogy' => false, 'sqlserver' => false }.freeze
+    # Places in a sort key, of which only the order counts: a value between a
+    # NULL sorted first and one sorted last, and false before true. Every
+    # value is a number, so that a descending key can negate it.
+    NULL_PLACE = { false => -1, true => 1 }.freeze
+    VALUE_PLACE = 0
+    BOOLEAN_VALUE = { false => 0, true => 1 }.freeze
+
+    # Whether the relation picks members by rank rather than by condition
+    # alone. A has_one takes the first record its order names.
+    #: (untyped, untyped) -> bool
+    def self.ranks?(relation, reflection)
+      !relation.limit_value.nil? || !relation.offset_value.nil? ||
+        (reflection.has_one? && !relation.order_values.empty?)
+    end
+
+    # A has_many, through or not, or a direct has_one is ranked per owner as
+    # its own query ranks it. A has_many through ranks the rows its join
+    # yields, a record reached twice counting twice, by its own order first.
+    # Returns nil when the ranking cannot be read exactly.
+    #: (untyped, untyped, untyped) -> ScopeRanking?
+    def self.build(relation, reflection, model_class)
+      return unless own?(reflection) && plain_offset?(relation)
+
+      keys = keys(relation.order_values, model_class)
+      return unless keys
+
+      nulls_last = NULLS_LAST[model_class.connection_db_config.adapter]
+      return if nulls_last.nil?
+
+      new(model_class, keys, nulls_last, relation.limit_value, relation.offset_value)
+    end
+
+    #: (untyped) -> bool
+    def self.own?(reflection)
+      reflection.macro == :has_many || (reflection.has_one? && !reflection.through_reflection?)
+    end
+    private_class_method :own?
+
+    # Active Record casts a limit to an integer but keeps an offset as given,
+    # which may be a String or SQL.
+    #: (untyped) -> bool
+    def self.plain_offset?(relation)
+      !relation.offset_value.is_a?(String)
+    end
+    private_class_method :plain_offset?
+
+    # The order's keys up to the primary key, which makes it total. Keys
+    # after it never decide anything.
+    #: (Array[untyped], untyped) -> Array[[String, bool]]?
+    def self.keys(nodes, model_class)
+      names = nodes.map { |node| column(node, model_class) }
+      total = names.index(model_class.primary_key)
+      return unless total
+
+      deciding = nodes.first(total + 1).zip(names)
+      return unless deciding.all? { |_node, name| name }
+
+      deciding.map do |node, name|
+        column = name #: String
+        [column, DIRECTIONS.fetch(node.class.name)]
+      end
+    end
+    private_class_method :keys
+
+    # The record's own column, sorted plainly in one direction.
+    #: (untyped, untyped) -> String?
+    def self.column(node, model_class)
+      return unless DIRECTIONS.key?(node.class.name)
+
+      attribute = node.expr
+      return unless ATTRIBUTE.eql?(attribute.class.name)
+
+      table = attribute.relation
+      return unless table.name == model_class.table_name && table.table_alias.nil?
+
+      name = attribute.name
+      name if orderable?(model_class, name)
+    end
+    private_class_method :column
+
+    #: (untyped, String) -> bool
+    def self.orderable?(model_class, name)
+      return false unless model_class.columns_hash.key?(name)
+
+      type = model_class.type_for_attribute(name)
+      type = type.subtype if ENUM_TYPE.eql?(type.class.name)
+      kinds = type.class.ancestors.map(&:name)
+      ORDER_TYPES.intersect?(kinds) ||
+        (kinds.include?(DATETIME_TYPE) && exact_time?(model_class, type))
+    end
+    private_class_method :orderable?
+
+    # Active Record truncates a time to its column's precision before writing
+    # it, so history holds the stored value when it keeps that many digits.
+    # Times the type stores in UTC sort as the instants they name; local
+    # times repeat an hour when clocks go back.
+    #: (untyped, untyped) -> bool
+    def self.exact_time?(model_class, type)
+      precision = type.precision
+      digits = StoredTimePrecision.digits(model_class)
+      !precision.nil? && (digits.nil? || digits >= precision) && type.default_timezone == :utc
+    end
+    private_class_method :exact_time?
+
+    #: (untyped, Array[[String, bool]], bool, Integer?, Integer?) -> void
+    def initialize(model_class, keys, nulls_last, limit, offset)
+      @model_class = model_class
+      @keys = keys
+      @nulls_last = nulls_last
+      @limit = limit
+      @offset = offset
+      freeze
+    end
+
+    # The members among records that met the scope's conditions, in order.
+    #: (Array[untyped]) -> Array[untyped]
+    def call(records)
+      offset = @offset
+      limit = @limit
+      ranked = records.sort_by { |record| sort_key(record.attributes) }
+      ranked = ranked.drop(offset) if offset
+      limit ? ranked.first(limit) : ranked
+    end
+
+    private
+
+    # @rbs @model_class: untyped
+    # @rbs @keys: Array[[String, bool]]
+    # @rbs @nulls_last: bool
+    # @rbs @limit: Integer?
+    # @rbs @offset: Integer?
+
+    # Keys compare in turn, and the primary key always decides. A descending
+    # key negates its places, which also moves NULL to the other end, as each
+    # adapter does by default.
+    #: (Hash[String, untyped]) -> Array[Array[Numeric]]
+    def sort_key(attributes)
+      @keys.map do |name, descending|
+        place = place(stored(name, attributes))
+        descending ? place.map(&:-@) : place
+      end
+    end
+
+    # NULL holds the adapter's place alone, so it never compares as a value.
+    # A version saved before its column existed holds NULL there too.
+    #: (untyped) -> Array[Numeric]
+    def place(value)
+      return [NULL_PLACE.fetch(@nulls_last)] if value.nil?
+
+      [VALUE_PLACE, number(value)]
+    end
+
+    # A time as its seconds, exactly, and a date as its day number.
+    #: (untyped) -> Numeric
+    def number(value)
+      value = BOOLEAN_VALUE.fetch(value, value)
+      value = value.jd if value.respond_to?(:jd)
+      value.to_r
+    end
+
+    # The value the database sorts by, as the key's type casts it. An enum
+    # sorts by the integer it stores; other types are compared cast, since an
+    # adapter may serialize a time or date as a wrapper, as SQL Server does.
+    #: (String, Hash[String, untyped]) -> untyped
+    def stored(name, attributes)
+      type = @model_class.type_for_attribute(name)
+      value = type.cast(attributes[name])
+      ENUM_TYPE.eql?(type.class.name) ? type.serialize(value) : value
+    end
+  end
+end

data/lib/paper_trail_diff/scoped_analysis_builder.rb

@@ -4,10 +4,10 @@
 module PaperTrailDiff
   # Selects both populations and checks their shared ceiling before analysis.
   class ScopedAnalysisBuilder
-    #: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped) -> void
+    #: (untyped, limit: Integer?, within: untyped, historical_filter: untyped, max_filter_versions: Integer, include_deleted: bool, analyzer: untyped, deleted_analyzer: untyped, ?activity_tree: AssociationTree?) -> void
     def initialize( # rubocop:disable Metrics/ParameterLists
       scope, limit:, within:, historical_filter:, max_filter_versions:, include_deleted:,
-      analyzer:, deleted_analyzer:
+      analyzer:, deleted_analyzer:, activity_tree: nil
     )
       raise ConfigurationError, 'limit: is required when selecting roots by scope' if limit.nil?
       unless [true, false].include?(include_deleted)
@@ -16,7 +16,8 @@ module PaperTrailDiff
 
       @selection = ScopedRootSelection.new(
         scope, limit: limit, time_range: within.nil? ? nil : TimeRange.new(within),
-               historical_filter: historical_filter, max_filter_versions: max_filter_versions
+               historical_filter: historical_filter, max_filter_versions: max_filter_versions,
+               activity_tree: activity_tree
       )
       @limit = limit
       @include_deleted = include_deleted

data/lib/paper_trail_diff/scoped_root_selection.rb

@@ -43,12 +43,20 @@ module PaperTrailDiff
       end
     end
 
-    #: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer) -> void
-    def initialize(scope, time_range:, limit:, historical_filter: nil,
-                   max_filter_versions: HistoricalFilter::DEFAULT_VERSION_LIMIT)
+    # `activity_tree` names the association paths whose changes also select a
+    # root, as an activity analysis reports them. Without one, only a root's
+    # own versions select it.
+    #: (untyped, time_range: TimeRange?, limit: Integer, ?historical_filter: untyped, ?max_filter_versions: Integer, ?activity_tree: AssociationTree?) -> void
+    def initialize(scope, time_range:, limit:, historical_filter: nil, # rubocop:disable Metrics/ParameterLists
+                   max_filter_versions: HistoricalFilter::DEFAULT_VERSION_LIMIT, activity_tree: nil)
       @scope = normalize_scope(scope)
+      reject_unversioned!
       @time_range = time_range
       @limit = validate_limit(limit)
+      @related = if activity_tree
+                   AssociationActivitySelection.new(model, tree: activity_tree,
+                                                           time_range: time_range)
+                 end
       @historical_filter = unless historical_filter.nil?
                              HistoricalFilter.new(base_class, predicate: historical_filter,
                                                               time_range: time_range, limit: @limit,
@@ -58,17 +66,11 @@ module PaperTrailDiff
 
     #: () -> Result
     def call
-      return database_selection if @historical_filter.nil? && comparable_keys?
+      related = @related&.call || []
+      queries = subqueries(related)
+      return database_selection(queries) if queries
 
-      candidates = versioned_ids
-      candidates = @historical_filter.call(candidates) if @historical_filter && candidates.any?
-      return Result.new(records: [], unreachable: []) if candidates.empty?
-
-      live = live_ids(candidates)
-      Result.new(
-        records: selected_records(live),
-        unreachable: (candidates - live).map { |id| identity(id) }.freeze
-      )
+      plucked_selection(versioned_ids | AssociationActivitySelection.values(related).map(&:to_s))
     end
 
     private
@@ -77,38 +79,67 @@ module PaperTrailDiff
     # @rbs @time_range: TimeRange?
     # @rbs @limit: Integer
     # @rbs @historical_filter: untyped
+    # @rbs @related: AssociationActivitySelection?
 
     # Leaves the candidate set in the database. Plucking every root changed in
     # the window would cost memory and a statement proportional to all activity
     # in the window -- not to the relation or `limit:` -- so a report on one
     # record could read every id in a busy table. A subquery keeps the work
     # bounded by what the relation and the deletions actually contain.
-    #: () -> Result
-    def database_selection
-      candidates = window_versions.select(:item_id)
+    #: (Array[AssociationActivitySelection::Query]) -> Result
+    def database_selection(related)
+      candidates = [window_versions.select(:item_id)] + related.map(&:relation)
+      missing = (missing_ids + related_missing_ids(related)).uniq.sort
       Result.new(
         records: selected_records(candidates),
-        unreachable: missing_ids.map { |id| identity(id) }.freeze
+        unreachable: missing.map { |id| identity(id) }.freeze
+      )
+    end
+
+    # Comparing in SQL needs every subquery's column to share the key's type.
+    #: (Array[AssociationActivitySelection::source]) -> Array[AssociationActivitySelection::Query]?
+    def subqueries(related)
+      return unless @historical_filter.nil? && comparable_keys?
+
+      queries = related.grep(AssociationActivitySelection::Query) #: Array[AssociationActivitySelection::Query]
+      matching = queries.select { |ids| ids.type == key_type }
+      matching if matching.length == related.length
+    end
+
+    #: (Array[String]) -> Result
+    def plucked_selection(candidates)
+      candidates = @historical_filter.call(candidates) if @historical_filter
+      live = live_ids(candidates)
+      Result.new(
+        records: selected_records([live]),
+        unreachable: (candidates - live).sort.map { |id| identity(id) }.freeze
       )
     end
 
     # Comparing the two columns in SQL needs them to share a type: PostgreSQL
-    # rejects an integer key against a string item_id outright.
+    # rejects an integer key against a string item_id outright. A composite
+    # key names no single attribute, so it has no type and never matches.
     #: () -> bool
     def comparable_keys?
-      return false unless primary_key.is_a?(String)
+      version_class.type_for_attribute('item_id').type == key_type
+    end
+
+    #: () -> Symbol?
+    def key_type
+      base_class.type_for_attribute(primary_key).type
+    end
 
-      item_id = version_class.columns_hash['item_id']&.type
-      key = base_class.columns_hash[primary_key]&.type
-      !item_id.nil? && item_id == key
+    #: (Array[AssociationActivitySelection::Query]) -> Array[String]
+    def related_missing_ids(related)
+      live = base_class.unscoped.select(primary_key).arel
+      related.flat_map { |ids| ids.missing(live) }.map(&:to_s)
     end
 
     # Changed in the window but without a row, found with an anti-join instead
     # of comparing two plucked lists.
     #: () -> Array[String]
     def missing_ids
-      live = base_class.unscoped.select(primary_key)
-      window_versions.where.not(item_id: live).distinct.pluck(:item_id).map(&:to_s).uniq.sort
+      window_versions.where.not(item_id: base_class.unscoped).distinct.pluck(:item_id).map(&:to_s)
     end
 
     #: () -> untyped
@@ -127,16 +158,21 @@ module PaperTrailDiff
         raise ConfigurationError, 'scope: must be an ActiveRecord relation or model class'
       end
 
-      relation = scope.all
-      return relation if Support.versioned?(relation.model)
+      scope.all
+    end
+
+    #: () -> void
+    def reject_unversioned!
+      return if Support.versioned?(model)
 
       raise UnversionedAssociationError,
-            "scope: #{relation.model.name} is not versioned, so it has no history to select from"
+            "scope: #{model} is not versioned, so it has no history to select from"
     end
 
+    # No Integer subclass has instances, so this is `is_a?` by another name.
     #: (Integer) -> Integer
     def validate_limit(limit)
-      return limit if limit.is_a?(Integer) && limit.positive?
+      return limit if limit.instance_of?(Integer) && limit.positive?
 
       raise ConfigurationError, 'limit: must be a positive Integer'
     end
@@ -146,7 +182,7 @@ module PaperTrailDiff
     # version table alone so that it does not depend on rows still existing.
     #: () -> Array[String]
     def versioned_ids
-      window_versions.distinct.pluck(:item_id).map(&:to_s).uniq
+      window_versions.distinct.pluck(:item_id).map(&:to_s)
     end
 
     # Which of those candidates still have a row, asked without the relation's
@@ -161,14 +197,15 @@ module PaperTrailDiff
     # Deduplicate records rather than adding SQL DISTINCT: an otherwise valid
     # relation may order by joined columns or select a PostgreSQL json column.
     # Read bounded pages until the relation ends or too many unique roots appear.
-    #: (untyped) -> Array[untyped]
-    def selected_records(live)
-      return [] if live.is_a?(Array) && live.empty?
-
+    # Each candidate source is an id list or a subquery; a record matching any
+    # of them is selected.
+    #: (Array[untyped]) -> Array[untyped]
+    def selected_records(candidates)
+      relation = candidate_relation(candidates)
       records = {} #: Hash[untyped, untyped]
       consumed = 0
       loop do
-        page = record_page(live, consumed)
+        page = record_page(relation, consumed)
         page.each { |record| records[record.id] ||= record }
         reject_oversized!(records.length)
         break if page.length < PAGE_SIZE
@@ -178,15 +215,20 @@ module PaperTrailDiff
       records.values.freeze
     end
 
+    #: (Array[untyped]) -> untyped
+    def candidate_relation(candidates)
+      candidates.map do |ids|
+        conditions = { primary_key => ids } #: Hash[untyped, untyped]
+        ordered_scope.where(conditions)
+      end.reduce(:or)
+    end
+
     #: (untyped, Integer) -> Array[untyped]
-    def record_page(live, consumed)
+    def record_page(relation, consumed)
       count = page_limit(consumed)
       return [] if count.zero?
 
-      # An id list or a candidate subquery; both read the same way in SQL.
-      conditions = { primary_key => live } #: Hash[untyped, untyped]
-      ordered_scope.where(conditions)
-                   .offset((@scope.offset_value || 0) + consumed).limit(count).to_a
+      relation.offset((@scope.offset_value || 0) + consumed).limit(count)
     end
 
     # Preserve explicit ordering: SQL Server rejects duplicate ORDER BY columns,
@@ -220,22 +262,30 @@ module PaperTrailDiff
 
     #: () -> String
     def item_type
-      base_class.name.to_s
+      base_class.name
+    end
+
+    # A relation delegates class methods to its model, so every mutation here,
+    # which drops `.model`, answers the same.
+    # mutant:disable
+    #: () -> untyped
+    def model
+      @scope.model
     end
 
     #: () -> untyped
     def base_class
-      @scope.model.base_class
+      model.base_class
     end
 
     #: () -> untyped
     def primary_key
-      @scope.model.primary_key
+      model.primary_key
     end
 
     #: () -> untyped
     def version_class
-      @scope.model.paper_trail.version_class
+      model.paper_trail.version_class
     end
   end
 end

data/lib/paper_trail_diff/snapshot_normalizer.rb

@@ -200,9 +200,8 @@ module PaperTrailDiff
       path,
       reifier
     )
-      # A reified history can hold a member PaperTrail could not rebuild.
-      records = Array(record.public_send(reflection.name)).compact
-      child_path = Support.association_path(path, reflection.name.to_s)
+      records = members(record, reflection)
+      child_path = Support.association_path(path, reflection.name)
       @structural_columns[child_path] ||= @traversal.incoming_relationship_columns(reflection)
       snapshot = AssociationSnapshot.new(
         kind: reflection.macro,
@@ -211,6 +210,14 @@ module PaperTrailDiff
       @pool.association(child_path, snapshot)
     end
 
+    # A reified history can hold a member PaperTrail could not rebuild. A
+    # through loads a record once per join that reaches it; it is one member,
+    # as Active Record compares records by class and id.
+    #: (untyped, untyped) -> Array[untyped]
+    def members(record, reflection)
+      Array(record.public_send(reflection.name)).compact.uniq
+    end
+
     #: (Array[untyped], AssociationTree, String, untyped) -> Array[RecordSnapshot]
     def normalize_children(records, tree, path, reifier)
       reflections_by_class = {} #: Hash[untyped, Array[untyped]]

data/lib/paper_trail_diff/support.rb

@@ -3,7 +3,7 @@
 
 module PaperTrailDiff
   # Internal helpers for isolating and serializing values held by result objects.
-  module Support
+  module Support # rubocop:disable Metrics/ModuleLength
     module_function
 
     #: (untyped) -> untyped
@@ -46,7 +46,12 @@ module PaperTrailDiff
 
     #: (untyped) -> Array[untyped]
     def chronological_version_key(version)
-      [version.created_at, version.id.to_s.rjust(32, '0')]
+      version_key(version.created_at, version.id)
+    end
+
+    #: (untyped, untyped) -> Array[untyped]
+    def version_key(created_at, id)
+      [created_at, id.to_s.rjust(32, '0')]
     end
 
     # Ordering falls back to the id whenever timestamps tie, which recovers the
@@ -124,9 +129,9 @@ module PaperTrailDiff
         raise(ConfigurationError, 'versions have incomparable timestamps')
     end
 
-    #: (String, String) -> String
+    #: (String, String | Symbol) -> String
     def association_path(parent, name)
-      parent.empty? ? name : "#{parent}.#{name}"
+      parent.empty? ? name.to_s : "#{parent}.#{name}"
     end
 
     #: (Hash[String, Hash[Symbol, untyped]], Hash[String, Hash[Symbol, untyped]]) -> Hash[String, Hash[Symbol, untyped]]

data/lib/paper_trail_diff/time_activity_timeline_builder.rb

@@ -194,7 +194,6 @@ module PaperTrailDiff
         @record,
         root_versions: root_versions,
         tree: @tree,
-        traversal: AssociationTraversal.new(@tree),
         prepared: (@snapshotter.activity_index if @snapshotter.respond_to?(:activity_index)),
         range_start: @range.begin_time,
         range_end: range_end || root_versions.last

data/lib/paper_trail_diff/time_range.rb

@@ -40,8 +40,7 @@ module PaperTrailDiff
 
     #: (untyped) -> untyped
     def trailing_scope(relation)
-      column = relation.klass.arel_table[:created_at]
-      relation.where(after_end(column))
+      relation.where(after_end(relation.arel_table[:created_at]))
     end
 
     # Each item's earliest version after the range, keyed by item id. One row
@@ -49,11 +48,11 @@ module PaperTrailDiff
     # the query stays portable; a timestamp tie keeps the lower id.
     #: (untyped) -> Hash[String, untyped]
     def first_trailing_versions(relation)
-      table = relation.klass.arel_table
+      table = relation.arel_table
       first_after = VersionQuery.no_earlier_version(table) do |earlier|
         after_end(earlier[:created_at])
       end
-      versions = VersionQuery.chronological(trailing_scope(relation).where(first_after)).to_a
+      versions = VersionQuery.chronological(trailing_scope(relation).where(first_after))
       first = {} #: Hash[String, untyped]
       versions.each { |version| first[version.item_id.to_s] ||= version }
       first
@@ -75,17 +74,15 @@ module PaperTrailDiff
 
     #: (untyped, boundary: Symbol) -> Time
     def coerce_time(value, boundary:)
-      unless value.respond_to?(:to_time)
-        raise InvalidTimeRangeError, "`within` #{boundary} must be time-like"
-      end
-
       time_value(value).getutc.freeze
-    rescue ArgumentError, NoMethodError, TypeError => e
-      raise InvalidTimeRangeError,
-            "`within` #{boundary} must be time-like",
-            cause: e
+    rescue ArgumentError, NoMethodError, TypeError
+      raise InvalidTimeRangeError, "`within` #{boundary} must be time-like"
     end
 
+    # Active Support 8.0 and older warn, once per process, that `to_time` will
+    # change on a zoned time, so read zoned values without it. Every branch
+    # gives the same instant, so no spec (and no mutation) can tell them apart.
+    # mutant:disable
     #: (untyped) -> Time
     def time_value(value)
       return value if value.is_a?(Time)

data/lib/paper_trail_diff/time_version_range.rb

@@ -4,18 +4,18 @@
 module PaperTrailDiff
   # Selects in-range root versions plus one later reconstruction boundary.
   class TimeVersionRange
-    #: (untyped, time_range: TimeRange, ?version_scope: untyped, ?live_endpoint: untyped) -> void
-    def initialize(record, time_range:, version_scope: nil, live_endpoint: nil)
+    #: (untyped, time_range: TimeRange, version_scope: untyped, live_endpoint: untyped) -> void
+    def initialize(record, time_range:, version_scope:, live_endpoint:)
       @record = record
       @time_range = time_range
       @version_scope = version_scope
       @live_endpoint = live_endpoint
     end
 
-    #: (?context_required: bool) -> RootVersionPlan
-    def select_plan(context_required: false)
+    #: (context_required: bool) -> RootVersionPlan
+    def select_plan(context_required:)
       relation = Endpoint.versions(@record)
-      in_range = ordered(@time_range.scope(relation).to_a)
+      in_range = ordered(@time_range.scope(relation))
       RootVersionSelection.new(
         in_range: in_range,
         selected: VersionScopeFilter.new(@version_scope).call(@time_range.scope(relation),

data/lib/paper_trail_diff/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module PaperTrailDiff
-  VERSION = '0.13.1'
+  VERSION = '0.14.0'
 end

data/lib/paper_trail_diff/version_association_candidate_scope.rb

@@ -44,7 +44,7 @@ module PaperTrailDiff
     def condition_sql(connection) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       outer = connection.quote_table_name(@version_class.table_name)
       later = connection.quote_table_name('paper_trail_diff_later_versions')
-      start_at = connection.quote(@start_at)
+      start_at = quote_time(connection, @start_at)
       columns = quoted_columns(connection, outer, later)
       compact_sql(<<~SQL)
         (
@@ -84,7 +84,17 @@ module PaperTrailDiff
       condition = "#{created_at} >= #{start_at}"
       return condition unless @end_at
 
-      "(#{condition} AND #{created_at} <= #{connection.quote(@end_at)})"
+      "(#{condition} AND #{created_at} <= #{quote_time(connection, @end_at)})"
+    end
+
+    # A time quoted on its own takes the adapter's default precision, which on
+    # SQL Server is `datetime` and rounds to 1/300 second. Serializing through
+    # the column's type quotes it as a bound value would be, at the precision
+    # `created_at` is stored with.
+    #: (untyped, untyped) -> String
+    def quote_time(connection, time)
+      type = @version_class.type_for_attribute('created_at')
+      connection.quote(type.serialize(type.cast(time)))
     end
 
     #: (untyped, String, String) -> String
@@ -94,7 +104,7 @@ module PaperTrailDiff
 
     #: (String) -> String
     def compact_sql(sql)
-      sql.gsub(/\s+/, ' ').strip
+      sql.split.join(' ')
     end
   end
 end