tape_deck 0.1.0.beta1 → 0.1.0

data/lib/tape_deck/adapters.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "adapters/base"
+require_relative "adapters/mysql"
+require_relative "adapters/postgres"
+require_relative "adapters/sqlite"
+
+module TapeDeck
+  # The database specific parts of taking snapshots: telling which tables changed, and turning column values into
+  # plain YAML values. Everything else goes through Sequel and works the same for every database.
+  module Adapters
+    # Adapters by +Sequel::Database#database_type+.
+    BY_DATABASE_TYPE = {mysql: MySQL, postgres: Postgres, sqlite: SQLite}.freeze
+
+    # @param db [Sequel::Database]
+    # @return [Base] the adapter for the database type. {Base} for other databases, which works, but reads every
+    #   table on every snapshot.
+    def self.for(db)
+      BY_DATABASE_TYPE.fetch(db.database_type, Base).new(db)
+    end
+  end
+end

data/lib/tape_deck/configuration.rb

@@ -33,6 +33,21 @@ module TapeDeck
     # @return [Array<String>] patterns added with {#exclude_columns}
     attr_reader :excluded_columns
 
+    # @return [Array<String>] patterns added with {#include_views}
+    attr_reader :included_views
+
+    # @return [Array<String>] patterns added with {#keep_new_ids}
+    attr_reader :kept_new_ids
+
+    # @return [Array<String>] patterns added with {#number_by_content}
+    attr_reader :numbered_by_content
+
+    # @return [Array<String>] patterns added with {#generated_keys}
+    attr_reader :generated_key_columns
+
+    # @return [Hash{String => Array<String>}] patterns added with {#references_to}, by referenced table
+    attr_reader :reference_columns
+
     def initialize
       @tape_library_dir = "spec/db_tapes"
       @databases = {}
@@ -40,6 +55,11 @@ module TapeDeck
       @on_schema_change = :error
       @excluded_tables = []
       @excluded_columns = []
+      @included_views = []
+      @kept_new_ids = []
+      @numbered_by_content = []
+      @generated_key_columns = []
+      @reference_columns = {}
     end
 
     # @param mode [Symbol] one of {Tape::RECORD_MODES}
@@ -80,9 +100,72 @@ module TapeDeck
       @excluded_columns.concat(patterns.map(&:to_s))
     end
 
+    # Adds matching views to snapshots. Views are left out by default, because the changes of the tables behind them
+    # are recorded anyway. Include them to also notice changed view definitions, or data a view reads from tables
+    # that are not recorded. Included views are read in full on every snapshot, and compared as a multiset of rows,
+    # because they have no primary key. {#exclude_columns} applies to their columns, {#exclude_tables} does not.
+    #
+    # @param patterns [Array<String>] globs on +"<database>.<view>"+
+    # @return [void]
+    # @example
+    #   c.include_views "shop.order_totals", "billing.*"
+    def include_views(*patterns)
+      @included_views.concat(patterns.map(&:to_s))
+    end
+
+    # Keeps the generated ids of rows inserted into matching tables, instead of replacing them with placeholders.
+    # See "New rows" in {TapeDeck}.
+    #
+    # @param patterns [Array<String>] globs on +"<database>.<table>"+
+    # @return [void]
+    # @example
+    #   c.keep_new_ids "shop.audit_log"
+    def keep_new_ids(*patterns)
+      @kept_new_ids.concat(patterns.map(&:to_s))
+    end
+
+    # Numbers the new rows of matching tables by their content instead of the order they were created in, so creating
+    # the same rows in a different order still verifies. For example an import, whose order doesn't matter. Rows with
+    # the same content are numbered in creation order. See "New rows" in {TapeDeck}.
+    #
+    # @param patterns [Array<String>] globs on +"<database>.<table>"+
+    # @return [void]
+    # @example
+    #   c.number_by_content "shop.imported_products"
+    def number_by_content(*patterns)
+      @numbered_by_content.concat(patterns.map(&:to_s))
+    end
+
+    # Marks matching primary keys as generated, like auto increment ones are: keys that the database or the
+    # application fills in, for example UUIDs. Their new rows get placeholders, see "New rows" in {TapeDeck}. Keys that
+    # are not integers have no creation order, so their rows are numbered by content.
+    #
+    # @param patterns [Array<String>] globs on +"<database>.<table>.<column>"+
+    # @return [void]
+    # @example
+    #   c.generated_keys "shop.tokens.id", "*.uuid"
+    def generated_keys(*patterns)
+      @generated_key_columns.concat(patterns.map(&:to_s))
+    end
+
+    # Marks matching columns as holding keys of a table, like a declared foreign key does. Needed for references
+    # across databases, and ones without a foreign key. Overrides a declared foreign key of the same column.
+    #
+    # @param table [String] +"<database>.<table>"+ whose keys the columns hold
+    # @param patterns [Array<String>] globs on +"<database>.<table>.<column>"+
+    # @return [void]
+    # @example
+    #   c.references_to "shop.orders", "billing.invoices.order_id", "*.last_order_id"
+    def references_to(table, *patterns)
+      (@reference_columns[table.to_s] ||= []).concat(patterns.map(&:to_s))
+    end
+
     # Wraps RSpec examples tagged +:tape_deck+ in a tape. The tape is named after the example's description hierarchy
     # unless +tape_name:+ is given. When the example fails, the tape is neither recorded nor verified.
     #
+    # Before the first example runs, the suite fails if tagged examples would share a tape file, for example the same
+    # description in a loop. See {.check_rspec_tape_names}.
+    #
     # @return [void]
     # @example
     #   it "creates an order", :tape_deck do ... end
@@ -90,11 +173,13 @@ module TapeDeck
     #   it "creates an order", tape_deck: { databases: %w[shop] } do ... end
     def configure_rspec_metadata!
       ::RSpec.configure do |config|
+        # All examples are loaded by now, so examples sharing a tape by mistake fail the run before anything is recorded
+        config.before(:suite) { Configuration.check_rspec_tape_names(::RSpec.world.all_examples) }
+
         config.around(:each, :tape_deck) do |example|
-          options = Hash.try_convert(example.metadata[:tape_deck]) || {} # a bare :tape_deck tag is `true`
-          name = options[:tape_name] || Configuration.rspec_tape_name(example)
+          name, options = Configuration.rspec_tape(example)
 
-          TapeDeck.insert_tape(name, **options.except(:tape_name))
+          TapeDeck.insert_tape(name, **options)
           example.run
           example_failed = !example.exception.nil?
           TapeDeck.eject_tape(discard: example_failed)
@@ -102,6 +187,34 @@ module TapeDeck
       end
     end
 
+    # @param example [RSpec::Core::Example] an example tagged +:tape_deck+
+    # @return [Array(String, Hash)] its tape name, and the options for {TapeDeck.insert_tape}
+    # @api private
+    def self.rspec_tape(example)
+      options = Hash.try_convert(example.metadata[:tape_deck]) || {} # a bare :tape_deck tag is `true`
+      name = options[:tape_name] || rspec_tape_name(example)
+      [name, options.except(:tape_name)]
+    end
+
+    # Examples that share a tape file would record and verify each other's changes, for example the same description
+    # in a loop. Explicit +tape_name:+ options count too.
+    #
+    # @param examples [Array<RSpec::Core::Example>] all loaded examples
+    # @return [void]
+    # @raise [Error] if tagged examples share a tape file, listing them
+    # @api private
+    def self.check_rspec_tape_names(examples)
+      tagged = examples.select { _1.metadata[:tape_deck] }
+      shared = tagged.group_by { Tape.file_name_for(rspec_tape(_1).first) }.select { |_, group| group.size > 1 }
+      return if shared.empty?
+
+      details = shared.map do |file_name, group|
+        lines = group.map { "    #{_1.id} #{rspec_tape(_1).first.inspect}" }
+        "  #{file_name}:\n#{lines.join("\n")}"
+      end
+      raise Error, "TapeDeck: examples share a tape. Give each its own description or tape_name:\n#{details.join("\n")}"
+    end
+
     # @param example [RSpec::Core::Example]
     # @return [String] the example's description hierarchy, e.g. +"Checkout/creates an order"+
     # @api private

data/lib/tape_deck/filter.rb

@@ -43,10 +43,9 @@ module TapeDeck
       kept.reject { |_, entries| entries.empty? }
     end
 
-    # Rows are sorted again, because their recorded order may depend on values that are now ignored.
     def filter_rows(table_name, rows)
       kept = rows.map { |row| filter_columns(table_name, row) }
-      kept.reject(&:empty?).sort_by(&:inspect)
+      kept.reject(&:empty?)
     end
 
     # The "key" of an update is kept as it is, because it identifies the row.

data/lib/tape_deck/new_rows.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # Replaces the generated keys of inserted rows with placeholders like +"new shop.orders 1"+, numbered per table, and
+  # references to those rows with the same placeholder. So a tape doesn't depend on where the database's counters
+  # stand. Ids of rows that existed before stay as they are. See "New rows" in {TapeDeck}.
+  #
+  # @api private
+  class NewRows
+    # @param recorder [Recorder] tells the generated keys and references of tables
+    # @param keep [Array<String>] patterns on +"<database>.<table>"+ for tables whose new ids are kept, see
+    #   {Configuration#keep_new_ids}
+    # @param by_content [Array<String>] patterns on +"<database>.<table>"+ for tables whose new rows are numbered by
+    #   content instead of creation order, see {Configuration#number_by_content}
+    # @param generated_keys [Array<String>] patterns for more generated keys, see {Configuration#generated_keys}
+    # @param references [Hash{String => Array<String>}] more references, see {Configuration#references_to}
+    def initialize(recorder, keep: [], by_content: [], generated_keys: [], references: {})
+      @recorder = recorder
+      @keep = keep
+      @by_content = by_content
+      @generated_keys = generated_keys
+      @references = references
+    end
+
+    # @param recorder [Recorder]
+    # @param tape_deck [Hash] the +tape_deck+ section of a tape, see {Tape#read}
+    # @return [NewRows] numbering with the rules the tape was recorded with
+    def self.recorded_with(recorder, tape_deck)
+      new(
+        recorder,
+        keep: tape_deck.fetch("keep_new_ids"),
+        by_content: tape_deck.fetch("number_by_content"),
+        generated_keys: tape_deck.fetch("generated_keys"),
+        references: tape_deck.fetch("references_to")
+      )
+    end
+
+    # @return [Hash] the rules, as stored in the +tape_deck+ section of a tape
+    def rules
+      {
+        "keep_new_ids" => @keep,
+        "number_by_content" => @by_content,
+        "generated_keys" => @generated_keys,
+        "references_to" => @references
+      }
+    end
+
+    # @param diff [Hash] a diff as stored on a tape
+    # @return [Hash] the diff with placeholders
+    def apply(diff)
+      keys = @recorder.generated_keys(diff, patterns: @generated_keys).to_h do |db_name, tables|
+        [db_name, tables.reject { |table, _| Patterns.match?(@keep, "#{db_name}.#{table}") }]
+      end
+      references = @recorder.references(diff, patterns: @references)
+      columns = diff.to_h do |db_name, tables|
+        [db_name, tables.keys.to_h { [_1, placeholder_columns(db_name, _1, keys, references)] }]
+      end
+      placeholders = number(diff, keys, columns)
+
+      diff.to_h do |db_name, tables|
+        [db_name, tables.to_h { |table, changes| [table, replace(changes, columns.dig(db_name, table), placeholders)] }]
+      end
+    end
+
+    private
+
+    # @return [Hash{String => Array(String, String)}] column -> +[database, table]+ whose new keys it can hold: the
+    #   table's own key, and its references
+    def placeholder_columns(db_name, table, keys, references)
+      key = keys.dig(db_name, table)
+      own_key = if key
+        {key => [db_name, table]}
+      else
+        {}
+      end
+      references.dig(db_name, table).to_h.merge(own_key)
+    end
+
+    # Tables numbered by content go after the ones they reference, so their content can hold those placeholders.
+    # Keys that are not integers, like UUIDs, tell nothing about creation order, so their tables are numbered by
+    # content too.
+    #
+    # @return [Hash{Array(String, String) => Hash{Object => String}}] +[database, table]+ -> key -> placeholder
+    def number(diff, keys, columns)
+      tables = keys.flat_map { |db_name, db_keys| db_keys.map { |table, key| [db_name, table, key] } }
+      new_keys = tables.to_h do |db_name, table, key|
+        [[db_name, table], diff.dig(db_name, table, "inserted").map { _1.fetch(key) }]
+      end
+      by_content, by_creation = tables.partition do |db_name, table, _|
+        content?(db_name, table) || !new_keys.fetch([db_name, table]).all?(Integer)
+      end
+
+      placeholders = {}
+      by_creation.each do |db_name, table, key|
+        rows = diff.dig(db_name, table, "inserted").sort_by { _1.fetch(key) }
+        placeholders[[db_name, table]] = assign(db_name, table, rows.map { _1.fetch(key) })
+      end
+      pending = by_content
+      until pending.empty?
+        ready = pending.reject do |db_name, table, _|
+          references_pending?(columns.dig(db_name, table), [db_name, table], pending)
+        end
+        ready = pending if ready.empty? # a cycle, see #content
+        ready.each do |db_name, table, key|
+          rows = diff.dig(db_name, table, "inserted")
+          sorted = rows.sort_by { [content(_1, key, columns.dig(db_name, table), placeholders, new_keys), _1.fetch(key)] }
+          placeholders[[db_name, table]] = assign(db_name, table, sorted.map { _1.fetch(key) })
+        end
+        pending -= ready
+      end
+      placeholders
+    end
+
+    def content?(db_name, table) = Patterns.match?(@by_content, "#{db_name}.#{table}")
+
+    def references_pending?(columns, own, pending)
+      pending_tables = pending.map { |db_name, table, _| [db_name, table] } - [own]
+      columns.values.any? { pending_tables.include?(_1) }
+    end
+
+    # The row without its key, as JSON. A reference to a new row that has no placeholder yet (the table references
+    # itself, or tables reference each other) only says which table it points to, because its id is not stable.
+    def content(row, key, columns, placeholders, new_keys)
+      values = row.except(key).to_h do |column, value|
+        target = columns[column]
+        replaced = if target.nil?
+          value
+        elsif placeholders.key?(target)
+          placeholders.dig(target, value) || value
+        elsif new_keys.fetch(target, []).include?(value)
+          "new #{target.join(".")}"
+        else
+          value
+        end
+        [column, replaced]
+      end
+      JSON.generate(values, allow_nan: true)
+    end
+
+    def assign(db_name, table, values)
+      values.each_with_index.to_h { |value, i| [value, "new #{db_name}.#{table} #{i + 1}"] }
+    end
+
+    # Rows that existed before keep their own ids, so only inserted rows and updated values can hold new ones.
+    #
+    # @param columns [Hash{String => Array(String, String)}] column -> +[database, table]+ whose new keys it can hold
+    def replace(changes, columns, placeholders)
+      swap = ->(column, value) do
+        target = columns[column]
+        (target && placeholders.dig(target, value)) || value
+      end
+      changes.to_h do |section, entries|
+        replaced = case section
+        when "inserted"
+          entries.map { |row| row.to_h { |column, value| [column, swap.call(column, value)] } }
+        when "updated"
+          entries.map do |update|
+            values = update.fetch("changes").to_h { |column, pair| [column, pair.map { swap.call(column, _1) }] }
+            update.merge("changes" => values)
+          end
+        else
+          entries
+        end
+        [section, replaced]
+      end
+    end
+  end
+end

data/lib/tape_deck/recorder.rb

@@ -4,7 +4,7 @@ module TapeDeck
   # Snapshot of one table.
   #
   # @!attribute [r] checksum
-  #   @return [Integer, nil] result of +CHECKSUM TABLE+
+  #   @return [Object, nil] checksum from the adapter, see {Adapters::Base#checksums}
   # @!attribute [r] pk
   #   @return [Array<String>] primary key columns, empty if the table has none
   # @!attribute [r] rows
@@ -13,26 +13,28 @@ module TapeDeck
   # @api private
   TableSnap = Data.define(:checksum, :pk, :rows)
 
-  # Takes snapshots of all configured databases and diffs them. Used by {Session}, but usable on its own when you don't
-  # need tape files.
+  # Takes snapshots of all configured databases and diffs them. The database specific parts are in {Adapters}. Used by
+  # {Session}, but usable on its own when you don't need tape files.
   class Recorder
-    # Database types of TIME columns, with or without fractional seconds. Sequel only types +time+ as +:time+, not
-    # +time(6)+.
-    TIME_DB_TYPE = /\Atime\b/i
-
     # @return [Array<String>] see {Configuration#exclude_tables}
     attr_reader :excluded_tables
 
     # @return [Array<String>] see {Configuration#exclude_columns}
     attr_reader :excluded_columns
 
+    # @return [Array<String>] see {Configuration#include_views}
+    attr_reader :included_views
+
     # @param dbs [Hash{String => Sequel::Database}]
     # @param exclude_tables [Array<String>] see {Configuration#exclude_tables}
     # @param exclude_columns [Array<String>] see {Configuration#exclude_columns}
-    def initialize(dbs, exclude_tables: [], exclude_columns: [])
+    # @param include_views [Array<String>] see {Configuration#include_views}
+    def initialize(dbs, exclude_tables: [], exclude_columns: [], include_views: [])
       @dbs = dbs
+      @adapters = dbs.transform_values { Adapters.for(_1) }
       @excluded_tables = exclude_tables
       @excluded_columns = exclude_columns
+      @included_views = include_views
     end
 
     # @yield the action whose database changes are recorded
@@ -43,8 +45,9 @@ module TapeDeck
       diff(before, snapshot(previous: before))
     end
 
-    # Reads all tables that are not excluded. With +previous:+, tables whose +CHECKSUM TABLE+ is unchanged reuse the
-    # previous snapshot, so only changed tables are read again.
+    # Reads all tables that are not excluded, and all included views. With +previous:+, tables whose checksum is
+    # unchanged reuse the previous snapshot, so only changed tables are read again. Views and tables without a
+    # checksum are always read again.
     #
     # @param previous [Hash, nil] an earlier result of this method
     # @return [Hash{String => Hash{String => TableSnap}}]
@@ -60,7 +63,8 @@ module TapeDeck
           end
           [table, snap]
         end
-        [name, tables]
+        views = view_names(db, name).to_h { [_1, dump(db, name, _1, nil, view: true)] }
+        [name, tables.merge(views)]
       end
     end
 
@@ -77,25 +81,78 @@ module TapeDeck
       end
     end
 
-    # What exclude rules leave out of each database, by default the ones this recorder was created with. Reads the
-    # current schema, so other rules show what they would have left out.
+    # Applies recording rules to the current schema of each database, by default the rules this recorder was created
+    # with. Other rules show what they would leave out and include.
     #
     # @param exclude_tables [Array<String>] table patterns, see {Configuration#exclude_tables}
     # @param exclude_columns [Array<String>] column patterns, see {Configuration#exclude_columns}
-    # @return [Hash{String => Array<String>}] database -> sorted +"<table>"+ and +"<table>.<column>"+ names
-    def exclusions(exclude_tables: @excluded_tables, exclude_columns: @excluded_columns)
+    # @param include_views [Array<String>] view patterns, see {Configuration#include_views}
+    # @return [Hash{String => Hash{String => Array<String>}}] database -> +"excluded"+: sorted +"<table>"+ and
+    #   +"<table>.<column>"+ names the exclude rules leave out, +"views"+: sorted names of the included views
+    def resolve(exclude_tables: @excluded_tables, exclude_columns: @excluded_columns, include_views: @included_views)
       @dbs.to_h do |db_name, db|
         tables = db.tables.map(&:to_s)
+        views = view_names(db, db_name, include_views)
         table_names = tables.select { Patterns.match?(exclude_tables, "#{db_name}.#{_1}") }
-        column_names = (tables - table_names).flat_map do |table|
+        column_names = (tables - table_names + views).flat_map do |table|
           excluded_column_names(db_name, table, db.schema(table.to_sym), exclude_columns).map { "#{table}.#{_1}" }
         end
-        [db_name, (table_names + column_names).sort]
+        [db_name, {"excluded" => (table_names + column_names).sort, "views" => views}]
+      end
+    end
+
+    # Generated keys of the tables the diff inserts rows into: a single primary key column that is auto increment,
+    # or matches one of the patterns. Views have none.
+    #
+    # @param diff [Hash] result of {#diff}
+    # @param patterns [Array<String>] globs on +"<database>.<table>.<column>"+, see {Configuration#generated_keys}
+    # @return [Hash{String => Hash{String => String}}] database -> table -> key column
+    def generated_keys(diff, patterns: [])
+      diff.to_h do |db_name, tables|
+        db = @dbs.fetch(db_name)
+        real_tables = db.tables.map(&:to_s)
+        keys = tables.filter_map do |table, changes|
+          next unless changes.key?("inserted") && real_tables.include?(table)
+
+          pk = db.schema(table.to_sym).select { |_, info| info[:primary_key] }
+          next unless pk.size == 1
+
+          column, info = pk.first
+          generated = info[:auto_increment] || Patterns.match?(patterns, "#{db_name}.#{table}.#{column}")
+          [table, column.to_s] if generated
+        end
+        [db_name, keys.to_h]
+      end
+    end
+
+    # Single column references of the tables in the diff: declared foreign keys, and columns that match the patterns.
+    # Matching patterns win over declared foreign keys.
+    #
+    # @param diff [Hash] result of {#diff}
+    # @param patterns [Hash{String => Array<String>}] +"<database>.<table>"+ -> globs on +"<database>.<table>.<column>"+
+    #   of columns holding its keys, see {Configuration#references_to}
+    # @return [Hash{String => Hash{String => Hash{String => Array(String, String)}}}] database -> table -> column ->
+    #   +[database, table]+ it references
+    def references(diff, patterns: {})
+      diff.to_h do |db_name, tables|
+        db = @dbs.fetch(db_name)
+        real_tables = db.tables.map(&:to_s)
+        references = tables.keys.select { real_tables.include?(_1) }.to_h do |table|
+          declared = db.foreign_key_list(table.to_sym).filter_map do |foreign_key|
+            [foreign_key[:columns].first.to_s, [db_name, foreign_key[:table].to_s]] if foreign_key[:columns].size == 1
+          end
+          configured = db.schema(table.to_sym).filter_map do |column, _|
+            target = patterns.find { |_, columns| Patterns.match?(columns, "#{db_name}.#{table}.#{column}") }&.first
+            [column.to_s, target.split(".", 2)] if target
+          end
+          [table, declared.to_h.merge(configured.to_h)]
+        end
+        [db_name, references]
       end
     end
 
     # @param db_name [String]
-    # @param name [String] +"<table>"+ or +"<table>.<column>"+, as returned by {#exclusions}
+    # @param name [String] +"<table>"+ or +"<table>.<column>"+, as returned by {#resolve}
     # @return [Boolean] whether the exclude rules leave this table or column out. Says nothing about primary keys,
     #   which are never left out.
     def excluded?(db_name, name)
@@ -118,6 +175,13 @@ module TapeDeck
       end
     end
 
+    # @return [Array<String>] sorted names of the views the patterns include
+    def view_names(db, db_name, patterns = @included_views)
+      return [] if patterns.empty?
+
+      db.views.map(&:to_s).select { Patterns.match?(patterns, "#{db_name}.#{_1}") }.sort
+    end
+
     # Diffs one database. A table missing on one side (created or dropped by the action) counts as empty there.
     def tables_diff(before, after)
       (before.keys | after.keys).sort.each_with_object({}) do |table, out|
@@ -129,23 +193,24 @@ module TapeDeck
       end
     end
 
-    # @return [Hash{String => Integer, nil}] table name -> checksum
+    # @return [Hash{String => Object, nil}] table name -> checksum, for the tables that are not excluded
     def checksums(db, name)
       tables = db.tables.map(&:to_s).sort.reject { excluded?(name, _1) }
-      return {} if tables.empty?
-
-      list = tables.map { db.literal(Sequel.identifier(_1)) }.join(", ")
-      db.fetch("CHECKSUM TABLE #{list}").to_h do |r|
-        _db_name, table = r[:Table].split(".", 2) # MySQL reports "<db>.<table>"
-        [table, r[:Checksum]]
-      end
+      @adapters.fetch(name).checksums(tables)
     end
 
+    # Views have no primary key. Whatever the schema says, their rows are compared as a multiset.
+    #
     # @return [TableSnap]
-    def dump(db, name, table, sum)
+    def dump(db, name, table, sum, view: false)
+      adapter = @adapters.fetch(name)
       schema = db.schema(table.to_sym)
-      pk = schema.select { |_, i| i[:primary_key] }.map(&:first)
-      types = schema.to_h { |col, i| [col, column_type(i)] }
+      pk = if view
+        []
+      else
+        schema.select { |_, i| i[:primary_key] }.map(&:first)
+      end
+      columns = schema.to_h
 
       drop = excluded_column_names(name, table, schema)
 
@@ -154,26 +219,16 @@ module TapeDeck
 
       rows = {}
       ds.each do |r|
-        row = r.except(*drop).to_h { |col, v| [col.to_s, serialize(v, types[col])] }
+        row = r.except(*drop).to_h { |col, v| [col.to_s, adapter.serialize(v, columns.fetch(col, {}))] }
         if pk.empty?
           rows[row] = rows.fetch(row, 0) + 1
         else
-          rows[pk.map { serialize(r[_1], types[_1]) }] = row
+          rows[pk.map { adapter.serialize(r[_1], columns[_1]) }] = row
         end
       end
       TableSnap.new(checksum: sum, pk: pk.map(&:to_s), rows: rows)
     end
 
-    # @param info [Hash] column info from +db.schema+
-    # @return [Symbol, nil] Sequel's column type, +:time+ for all TIME columns, see {TIME_DB_TYPE}
-    def column_type(info)
-      if TIME_DB_TYPE.match?(info[:db_type].to_s)
-        :time
-      else
-        info[:type]
-      end
-    end
-
     def empty_like(snap) = TableSnap.new(checksum: nil, pk: snap.pk, rows: {})
 
     def table_diff(b, a)
@@ -216,55 +271,7 @@ module TapeDeck
       compact("inserted" => sort_rows(inserted), "deleted" => sort_rows(deleted))
     end
 
-    def sort_rows(rows) = rows.sort_by(&:inspect)
+    def sort_rows(rows) = Rows.sort(rows)
     def compact(h) = h.reject { |_, v| v.empty? }
-
-    # Converts a column value to a YAML-stable scalar. +type+ is the column type from +db.schema+.
-    def serialize(v, type = nil)
-      case v
-      when String then maybe_utf8(v)
-      when BigDecimal then v.to_s("F")
-      when Sequel::SQLTime then time_of_day(v)
-      when Time then timestamp(v, type)
-      when Date then v.iso8601
-      else v # Integer, Float, true/false, nil
-      end
-    end
-
-    # mysql2 returns TIME columns as a +Time+ on 2000-01-01, not as +Sequel::SQLTime+. Those keep their local time of
-    # day, because converting them to UTC would shift the hour.
-    def timestamp(v, type)
-      if type == :time
-        time_of_day(v)
-      else
-        v.utc.iso8601(6)
-      end
-    end
-
-    def time_of_day(v) = v.strftime("%H:%M:%S.%6N")
-
-    # Small binaries encode as hex. Large ones are shown as a digest so the YAML stays small.
-    def bin(v)
-      if v.bytesize <= 64
-        "0x#{v.unpack1("H*")}"
-      else
-        "sha256:#{Digest::SHA256.hexdigest(v)}"
-      end
-    end
-
-    # BINARY, VARBINARY and BLOB columns arrive as ASCII-8BIT strings (or Sequel::SQL::Blob, depending on the adapter).
-    # Ones that hold valid UTF-8 become plain UTF-8 strings, because YAML would otherwise store them as base64
-    # (+!binary+). Everything else goes through {#bin}.
-    def maybe_utf8(v)
-      binary = v.encoding == Encoding::BINARY || v.is_a?(Sequel::SQL::Blob)
-      return v unless binary
-
-      utf8 = String.new(v, encoding: Encoding::UTF_8)
-      if utf8.valid_encoding?
-        utf8
-      else
-        bin(v)
-      end
-    end
   end
 end

data/lib/tape_deck/rows.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module TapeDeck
+  # A stable order for rows, so tapes come out the same on every Ruby version. Rows hold plain values only, see
+  # {Adapters::Base#serialize}, and the JSON format pins down how those are written. +inspect+ does not, it changed
+  # in Ruby 3.4.
+  #
+  # @api private
+  module Rows
+    # @param rows [Array<Hash>]
+    # @return [Array<Hash>] sorted by their JSON
+    def self.sort(rows)
+      rows.sort_by { JSON.generate(_1, allow_nan: true) }
+    end
+  end
+end