db

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

type CompactionOp struct {
	Key    []byte
	OldPtr page.ValuePtr
	NewPtr page.ValuePtr
}

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

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

type DBState struct {
	CommitSeq        uint64
	RootPageID       uint64
	SystemRootPageID uint64
	SlabSet          *slab.SlabSet
	ValueLogSet      *vlog.Set
}

type IndexSwapCompactionOptions struct {
	// CopyBytesPerSec limits slab copy IO. 0 disables throttling.
	CopyBytesPerSec int64
	// CopyBurstBytes is the limiter burst size. 0 uses a 1-second burst.
	CopyBurstBytes int64

	// Assist is an optional hook invoked periodically during compaction work.
	// It must be fast and must not assume any DB locks are held.
	Assist func()

	// Stats captures timing and byte counters for the compaction run.
	Stats *IndexSwapCompactionStats
}

type IndexSwapCompactionStats struct {
	TotalNanos    uint64
	BuildNanos    uint64
	CatchupNanos  uint64
	FinalizeNanos uint64

	RemapCount uint64
	RemapBytes uint64

	SlabWriteBytes int
	SlabDeadBytes  int
}

type Iterator interface {
	Valid() bool
	Next()
	Key() []byte
	Value() []byte
	KeyCopy(dst []byte) []byte
	ValueCopy(dst []byte) []byte
	Close() error
	Error() error
	// Reset resets the iterator for reuse.
	Reset(start, end []byte)
}

type Mode uint8

type Options struct {
	Dir string
	// ReadOnly opens the database without acquiring an exclusive lock and without
	// modifying on-disk state (no recovery truncation, no WAL replay, no background
	// maintenance). Only read operations are supported.
	ReadOnly   bool
	ChunkSize  int64  // Default 256MB
	KeepRecent uint64 // Default 10000
	// DisableBackgroundPrune keeps pruning on the commit critical path (legacy
	// behavior). When false (default), a bounded background pruner frees pages
	// asynchronously to reduce commit latency under churn.
	DisableBackgroundPrune bool
	// PruneInterval controls how often the background pruner wakes up (0 uses a
	// default).
	PruneInterval time.Duration
	// PruneMaxPages bounds how many pages are freed per pruner tick (0 uses a
	// default; <0 means unlimited).
	PruneMaxPages int
	// PruneMaxDuration bounds how long a pruner tick may run (0 uses a default;
	// <0 means unlimited).
	PruneMaxDuration time.Duration

	// BackgroundCompactionInterval enables background slab compaction when > 0.
	// Background compaction is managed by the public wrapper (TreeDB/Open) so it
	// can coordinate with the caching layer.
	BackgroundCompactionInterval          time.Duration
	BackgroundCompactionMaxSlabs          int
	BackgroundCompactionDeadRatio         float64
	BackgroundCompactionMinBytes          uint64
	BackgroundCompactionMicroBatch        int
	BackgroundCompactionCopyBytesPerSec   int64
	BackgroundCompactionCopyBurstBytes    int64
	BackgroundCompactionRotateBeforeWrite bool
	// BackgroundCompactionIndexSwap compacts slabs by rebuilding the index into a
	// new file and swapping it in once per pass (two-index-file approach). This
	// can drastically reduce index churn during large slab pointer rewrites.
	BackgroundCompactionIndexSwap bool
	// BackgroundIndexVacuumInterval enables background index vacuum when > 0.
	// The worker uses FragmentationReport span ratio to decide if a rebuild is
	// warranted; see BackgroundIndexVacuumSpanRatioPPM.
	BackgroundIndexVacuumInterval time.Duration
	// BackgroundIndexVacuumSpanRatioPPM is the span ratio threshold (ppm) that
	// triggers a background index vacuum. Zero uses a default.
	BackgroundIndexVacuumSpanRatioPPM uint32

	Mode           Mode // Default ModeCached
	FlushThreshold int64
	// MemtableMode selects the cached-mode memtable implementation.
	// Supported values: "skiplist", "hash_sorted", "btree", "adaptive".
	MemtableMode string
	// MemtableShards controls the number of mutable memtable shards in cached
	// mode. Values <= 0 use a runtime-dependent default.
	MemtableShards int
	// PreferAppendAlloc makes the page allocator ignore the freelist and append
	// new pages instead. This can improve scan locality under churn at the cost
	// of file growth (space is reclaimed later via vacuum).
	PreferAppendAlloc bool
	// FreelistRegionPages and FreelistRegionRadius bias freelist reuse toward
	// nearby page regions to improve locality. Leave both at 0 to disable the
	// bias (default). If either is set, missing values will use defaults.
	// Set FreelistRegionRadius < 0 to force-disable the bias.
	FreelistRegionPages  uint64
	FreelistRegionRadius int

	// LeafFillTargetPPM and InternalFillTargetPPM control how full newly-written
	// B+Tree pages are allowed to become before forcing a split (soft-full).
	// Lower values reduce split churn and slow re-fragmentation under updates, at
	// the cost of higher page count (more index bytes).
	//
	// Values are in parts-per-million where 1_000_000 means "allow full pages"
	// (current behavior). Zero uses the default (1_000_000).
	LeafFillTargetPPM     uint32
	InternalFillTargetPPM uint32
	// LeafPrefixCompression enables prefix-compressed leaf nodes for new pages.
	LeafPrefixCompression bool
	// MaxQueuedMemtables controls how much immutable-memtable backlog the cached
	// layer will allow before applying backpressure (i.e. forcing flush work on
	// writers). A negative value disables backpressure entirely (higher short-term
	// ingest, but potentially unbounded flush debt). Zero uses the default.
	MaxQueuedMemtables int

	// SlowdownBacklogSeconds begins applying writer backpressure when queued flush
	// backlog exceeds this many seconds of estimated flush work (0 disables).
	SlowdownBacklogSeconds float64
	// StopBacklogSeconds blocks writers when queued flush backlog exceeds this many
	// seconds of estimated flush work (0 disables).
	StopBacklogSeconds float64
	// MaxBacklogBytes is an absolute cap on queued flush backlog bytes (0 disables).
	MaxBacklogBytes int64

	// WriterFlushMaxMemtables bounds how much queued work a writer will help flush
	// per write when backpressure is active (0 uses a default).
	WriterFlushMaxMemtables int
	// WriterFlushMaxDuration bounds how long a writer will spend helping flush per
	// write when backpressure is active (0 disables the time bound).
	WriterFlushMaxDuration time.Duration
	// FlushBuildConcurrency controls how many goroutines may be used to build a
	// combined flush batch from multiple immutable memtables in cached mode.
	// Values <= 1 disable parallelism.
	FlushBuildConcurrency int

	// DisableSlabTailRepairOnOpen disables best-effort recovery that truncates
	// partial/corrupt tail records on the active slab. Disabling may reduce open
	// latency for very large slabs but risks starting up with committed pointers
	// that decode to checksum errors after a crash.
	DisableSlabTailRepairOnOpen bool
	// AllowUnsafe acknowledges unsafe durability/integrity options.
	// When false, Open will reject options that disable WAL, fsync, checksums,
	// or slab tail repair.
	AllowUnsafe bool

	// DisableWAL disables the Write-Ahead Log in cached mode.
	// This improves performance but sacrifices durability: a crash will revert
	// the database to the last Checkpoint (backend flush).
	DisableWAL bool
	// DisableValueLog forces cached-mode WAL to remain in legacy mode (no value-log pointers).
	DisableValueLog bool
	// SplitValueLog stores WAL records in wal/ while large values go to vlog/
	// segments, and WAL entries reference them via pointers.
	SplitValueLog bool
	// WALMaxSegmentBytes caps the size of a single WAL segment payload.
	// 0 uses the default limit.
	WALMaxSegmentBytes int64
	// MemtableValueLogPointers avoids storing large values in the memtable and
	// serves them by pointer from the value log (WAL/vlog). Requires WAL/value-log.
	MemtableValueLogPointers bool
	// ValueLogPointerThreshold controls when WAL/vlog pointers are used.
	// Values <= 0 use the default inline threshold (256 bytes).
	ValueLogPointerThreshold int
	// ForceValuePointers stores all values out-of-line in slabs (no inline values).
	ForceValuePointers bool
	// MaxValueLogRetainedBytes emits a warning when retained value-log bytes exceed
	// this threshold (0 disables warnings). Cached mode only.
	MaxValueLogRetainedBytes int64
	// MaxValueLogRetainedBytesHard disables value-log pointers for new large
	// values once retained bytes exceed this threshold (0 disables the cap).
	MaxValueLogRetainedBytesHard int64

	// RelaxedSync disables fsync on CommitSync and SetSync operations.
	// This improves performance for synchronous workloads but provides only
	// crash consistency (OS buffer cache), not true durability.
	RelaxedSync bool

	// NotifyError is an optional hook for background maintenance failures.
	NotifyError func(error)

	// DisableReadChecksum skips CRC verification on slab reads.
	// This improves read performance (especially for large values) but risks
	// returning silent data corruption if the disk/memory is compromised.
	DisableReadChecksum bool
	// SlabCompression configures compression for slab-stored values.
	SlabCompression slab.CompressionOptions
	// VerifyOnRead forces checksum verification on every index page read,
	// bypassing the verified-page cache.
	VerifyOnRead bool

	// DisablePiggybackCompaction disables opportunistic defragmentation during writes.
	// When false (default), nodes are rewritten if their siblings are physically
	// distant, keeping the tree clustered. Set to true to maximize write speed.
	DisablePiggybackCompaction bool

	// BackgroundCheckpointInterval enables periodic durable checkpoints in cached
	// mode. A checkpoint creates a backend sync boundary and trims
	// cached-mode WAL segments to keep `wal/` growth bounded.
	//
	// Semantics:
	// - `0` uses a default.
	// - `<0` disables the periodic interval trigger.
	BackgroundCheckpointInterval time.Duration
	// BackgroundCheckpointIdleDuration triggers an opportunistic checkpoint after
	// a period of write-idleness in cached mode.
	//
	// Semantics:
	// - `0` uses a default.
	// - `<0` disables the idle trigger.
	BackgroundCheckpointIdleDuration time.Duration
	// MaxWALBytes triggers an immediate checkpoint in cached mode when the sum of
	// WAL segment sizes exceeds this many bytes (0 uses a default; <0 disables the
	// size trigger). This is an operational safety cap; it does not make each
	// individual write durable (use *Sync APIs for that).
	MaxWALBytes int64
}

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

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

type WritePolicy struct {
	FlushThreshold  int64 // Size of memtable before flush
	InlineThreshold int   // Max size of value to store inline
}