databranchutils

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

type BranchHashmap interface {
	// PutByVectors stores the provided vectors. Each row across the vectors is
	// treated as a single record and the columns referenced by keyCols build the key.
	PutByVectors(vecs []*vector.Vector, keyCols []int) error
	// GetByVectors probes the map using the supplied key vectors and returns one
	// GetResult per probed row, preserving the order of the original vectors. The
	// returned rows reference the internal storage and must be treated as read-only.
	GetByVectors(keyVecs []*vector.Vector) ([]GetResult, error)
	// GetByEncodedKey retrieves rows using a pre-encoded key such as one obtained
	// from ForEachShardParallel. Returned rows reference internal storage and must
	// be treated as read-only.
	GetByEncodedKey(encodedKey []byte) (GetResult, error)
	// PopByVectors behaves like GetByVectors but removes matching rows from the
	// hashmap. When removeAll is true, all rows associated with a key are removed.
	// When removeAll is false, only a single row is removed. Returned rows are
	// detached copies because the underlying entries have been removed.
	PopByVectors(keyVecs []*vector.Vector, removeAll bool) ([]GetResult, error)
	// PopByVectorsStream removes rows like PopByVectors but streams each matched
	// row to the callback. The callback receives the original key row index plus
	// the encoded key/value; the slices are detached copies and safe to keep.
	// The returned integer counts removed rows.
	PopByVectorsStream(keyVecs []*vector.Vector, removeAll bool, fn func(idx int, key []byte, row []byte) error) (int, error)
	// PopByEncodedKey removes rows using a pre-encoded key such as one obtained
	// from ForEachShardParallel. It mirrors PopByVectors semantics.
	PopByEncodedKey(encodedKey []byte, removeAll bool) (GetResult, error)
	// PopByEncodedKeyValue removes rows matching both the encoded key and encoded
	// value. When removeAll is true it removes all matching rows, otherwise it
	// removes a single row. It returns the number of rows removed.
	PopByEncodedKeyValue(encodedKey []byte, encodedValue []byte, removeAll bool) (int, error)
	// PopByEncodedFullValue PopByEncodedFullValues removes rows by reconstructing the key from a full
	// encoded row payload. The full row must match the value encoding used by
	// PutByVectors. It mirrors PopByEncodedKey semantics.
	PopByEncodedFullValue(encodedValue []byte, removeAll bool) (GetResult, error)
	// PopByEncodedFullValueExact removes rows by matching the full encoded row
	// payload, including the value bytes. It mirrors PopByEncodedKeyValue semantics.
	PopByEncodedFullValueExact(encodedValue []byte, removeAll bool) (int, error)
	// ForEachShardParallel provides exclusive access to each shard. The callback
	// receives a cursor offering read-only iteration plus mutation helpers that
	// avoid blocking other shards. parallelism <= 0 selects the default value:
	// min(runtime.NumCPU(), shardCount), clamped to [1, shardCount].
	ForEachShardParallel(fn func(cursor ShardCursor) error, parallelism int) error
	// Project rebuilds a new hashmap using the provided keyCols from the current
	// rows. parallelism controls shard-level fan-out; see ForEachShardParallel
	// for the clamping rules. The returned hashmap owns its own storage and is
	// independent from the source.
	Project(keyCols []int, parallelism int) (BranchHashmap, error)
	// Migrate rebuilds a new hashmap using the provided keyCols while freeing
	// rows from the current map during the process. This reduces peak memory
	// when Project would duplicate data. parallelism follows ForEachShardParallel
	// semantics.
	Migrate(keyCols []int, parallelism int) (BranchHashmap, error)
	// ItemCount reports the number of rows currently stored in the hashmap.
	ItemCount() int64
	// ShardCount reports the number of shards in the hashmap.
	ShardCount() int
	// DecodeRow turns the encoded row emitted by Put/Get/Pop/ForEach back into a
	// tuple of column values in the same order that was originally supplied.
	DecodeRow(data []byte) (types.Tuple, []types.Type, error)
	Close() error
}

type BranchHashmapOption func(*branchHashmap)

type BranchReclaimDag struct {
	Children map[uint64][]uint64
	Info     map[uint64]BranchReclaimNode
}

type BranchReclaimNode struct {
	ParentTableID uint64
	CloneTS       int64
	Deleted       bool
}

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

type DataBranchMetadata struct {
	TableID      uint64
	CloneTS      int64
	PTableID     uint64
	TableDeleted bool
}

type GetResult struct {
	// Exists reports whether at least one row matched the probed key.
	Exists bool
	// Rows contains the encoded payloads for every row that matched the key.
	// When obtained via GetByVectors the slices alias the internal storage and
	// must be treated as read-only views. Results returned by Pop* are copies.
	Rows [][]byte
}

type ShardCursor interface {
	// ShardID returns the zero-based shard identifier.
	ShardID() int
	// ForEach visits every encoded key stored inside the shard, including rows
	// that have spilled to disk. The callback is invoked per entry with a single
	// payload row. The provided slices reference internal buffers (or scratch
	// copies for spilled data) and are only valid inside the callback.
	ForEach(fn func(key []byte, row []byte) error) error
	// GetByEncodedKey retrieves rows using a pre-encoded key while the caller
	// still owns the iteration lock.
	GetByEncodedKey(encodedKey []byte) (GetResult, error)
	// PopByEncodedKey removes entries from the shard while the caller still owns
	// the iteration lock, ensuring In-shard mutations stay non-blocking.
	PopByEncodedKey(encodedKey []byte, removeAll bool) (GetResult, error)
	// PopByEncodedKeyValue removes entries matching both key and value while the
	// caller still owns the iteration lock.
	PopByEncodedKeyValue(encodedKey []byte, encodedValue []byte, removeAll bool) (int, error)
}