compaction

type BackgroundCompactor struct {
	// contains filtered or unexported fields
}

type BackgroundConfig struct {
	// Enabled controls whether background compaction runs. Default: true.
	Enabled bool
	// Interval between compaction sweeps. Zero uses DefaultCompactionInterval.
	Interval time.Duration
	// Compaction controls compaction trigger thresholds.
	Compaction Config
	// GCMinAge is the minimum age before delete markers are garbage collected
	// and their files are force-rewritten. Zero uses DefaultGCMinAge.
	GCMinAge time.Duration
	// DropGrace is the minimum age before a dropped table's data files are
	// physically deleted (catalog.Catalog.FlushDroppedTableFiles). Zero
	// uses catalog.DefaultDropTableGrace. Only consulted when
	// ReclaimDroppedTables is true.
	DropGrace time.Duration
	// ReclaimDroppedTables controls whether the sweep calls
	// catalog.Catalog.FlushDroppedTableFiles at all. Default: false.
	//
	// Deliberately opt-in rather than tied to Enabled (#494 review): this
	// *Catalog is not the only one a DROP can go through. An embedded
	// wadjet.DB and a standalone pgwire DB each own a separate *Catalog
	// from the one a BackgroundCompactor sweeps (cmd/wadjet/main.go's
	// standalone mode is the concrete case — its pgwire server opens its
	// own wadjet.DB), so turning this on unconditionally would reclaim a
	// DROPped table's files for queries issued through the compactor's
	// catalog while silently never reclaiming ones issued through psql or
	// the embedded API against the others. An explicit, honest default of
	// "not reclaimed anywhere yet" beats an inconsistent "reclaimed here,
	// not there" that looks like a bug until someone reads the wiring.
	// Turning it on is safe wherever it runs: FlushDroppedTableFiles's
	// live-manifest guard and table-prefix scoping hold regardless of
	// which *Catalog instance calls it.
	ReclaimDroppedTables bool
}

type CompactionFailed struct {
	Table     string
	Failures  []PartitionFailure
	Compacted int
}

type Compactor struct {
	// contains filtered or unexported fields
}

type Config struct {
	// MinFiles is the minimum file count per partition to trigger compaction.
	MinFiles int
	// MaxFileSizeBytes is the average size below which compaction triggers.
	MaxFileSizeBytes int64
	// MaxFilesPerPass caps the number of files merged in one compaction pass
	// to bound memory usage.
	MaxFilesPerPass int
	// DeleteGrace is how long a compacted-away file stays physically present
	// in the object store after its manifest entry is removed. In-flight
	// tasks hold file lists resolved at DISPATCH time; deleting the bytes
	// the instant the manifest swaps races every running query against the
	// compactor (observed 2026-06-11: first successful mid-benchmark
	// compaction at SF10 deleted chunks under three dispatched scan tasks →
	// "object not found" ×5 → circuit breaker open → every later query
	// failed). Mirrors DefaultGCMinAge's reasoning. Zero uses
	// DefaultDeleteGrace; negative deletes immediately (tests).
	DeleteGrace time.Duration
}

type PartitionFailure struct {
	Partition string
	Err       error
}

type Result struct {
	Table string
	// PartitionsCompacted counts successful MERGES, not distinct partitions:
	// a partition compacted over three passes, or rewritten as three
	// memory-bounded groups, counts three times.
	PartitionsCompacted int
	FilesRemoved        int
	FilesCreated        int
	RowsMerged          int64
	BytesBefore         int64
	BytesAfter          int64
	Failed              []PartitionFailure

	// PassLimitReached reports that the multi-pass loop stopped at
	// maxCompactionPasses with the table still shrinking. It is a flag on a
	// SUCCESSFUL result rather than an error: every one of those passes had
	// to remove more files than it created to get there (the progress rule
	// in CompactTable), so the work is real and committed, and calling the
	// call a failure would discard a correct result and — through the
	// background sweep's `continue` on error — skip the table's
	// delete-marker GC as well. The next sweep picks the table up where
	// this one left off.
	PassLimitReached bool
}