@quereus/quereus 0.7.3 → 0.7.4

package/src/vtab/memory/index.ts

@@ -1,191 +0,0 @@
-import { BTree } from 'inheritree';
-import { StatusCode, type Row, type SqlValue } from '../../common/types.js';
-import { createTypedComparator, resolveCollation } from '../../util/comparison.js';
-import type { BTreeKeyForPrimary, BTreeKeyForIndex, MemoryIndexEntry } from './types.js';
-import type { IndexColumnSchema as IndexColumnSpec } from '../../schema/table.js'; // Renamed for clarity
-import type { ColumnSchema } from '../../schema/column.js';
-import { quereusError } from '../../common/errors.js';
-
-/** Definition for creating a memory index (matches IndexSchema columns usually) */
-export interface IndexSpec {
-	name?: string;
-	columns: ReadonlyArray<IndexColumnSpec>;
-}
-
-/** Functions for extracting and comparing index keys */
-interface IndexKeyFunctions {
-	keyFromRow: (row: Row) => BTreeKeyForIndex;
-	compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
-}
-
-/** Represents a secondary index within a MemoryTable */
-export class MemoryIndex {
-	public readonly name: string | undefined;
-	public readonly specColumns: ReadonlyArray<IndexColumnSpec>;
-	public readonly keyFromRow: (row: Row) => BTreeKeyForIndex;
-	public readonly compareKeys: (a: BTreeKeyForIndex, b: BTreeKeyForIndex) => number;
-	public data: BTree<BTreeKeyForIndex, MemoryIndexEntry>;
-	private readonly allTableColumnsSchema: ReadonlyArray<ColumnSchema>;
-
-	constructor(spec: IndexSpec, allTableColumnsSchema: ReadonlyArray<ColumnSchema>, baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>) {
-		this.name = spec.name;
-		this.specColumns = Object.freeze(spec.columns.map(c => ({ ...c })));
-		this.allTableColumnsSchema = allTableColumnsSchema;
-
-		this.validateColumnIndexes(allTableColumnsSchema);
-
-		const keyFunctions = this.createIndexKeyFunctions();
-		this.keyFromRow = keyFunctions.keyFromRow;
-		this.compareKeys = keyFunctions.compareKeys;
-
-		this.data = this.createBTree(baseInheritreeTable);
-	}
-
-	private validateColumnIndexes(allTableColumnsSchema: ReadonlyArray<ColumnSchema>): void {
-		const hasInvalidIndex = this.specColumns.some(sc =>
-			sc.index < 0 || sc.index >= allTableColumnsSchema.length
-		);
-
-		if (hasInvalidIndex) {
-			quereusError(`Invalid column index in index '${this.name ?? '(unnamed)'}'.`, StatusCode.INTERNAL);
-		}
-	}
-
-	private createIndexKeyFunctions(): IndexKeyFunctions {
-		if (this.specColumns.length === 1) {
-			return this.createSingleColumnKeyFunctions();
-		} else {
-			return this.createCompositeColumnKeyFunctions();
-		}
-	}
-
-	private createSingleColumnKeyFunctions(): IndexKeyFunctions {
-		const specCol = this.specColumns[0];
-		const colSchemaIndex = specCol.index;
-		const columnSchema = this.allTableColumnsSchema[colSchemaIndex];
-		const descMultiplier = specCol.desc ? -1 : 1;
-
-		// Create type-aware comparator
-		const collationFunc = specCol.collation ? resolveCollation(specCol.collation) : undefined;
-		const typedComparator = createTypedComparator(columnSchema.logicalType, collationFunc);
-
-		const keyFromRow = (row: Row): BTreeKeyForIndex => {
-			this.validateRowLength(row, colSchemaIndex);
-			return row[colSchemaIndex];
-		};
-
-		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
-			return typedComparator(a as SqlValue, b as SqlValue) * descMultiplier;
-		};
-
-		return { keyFromRow, compareKeys };
-	}
-
-	private createCompositeColumnKeyFunctions(): IndexKeyFunctions {
-		const localSpecColumns = this.specColumns;
-
-		// Pre-create type-aware comparators for each column
-		const comparators = localSpecColumns.map(sc => {
-			const columnSchema = this.allTableColumnsSchema[sc.index];
-			const collationFunc = sc.collation ? resolveCollation(sc.collation) : undefined;
-			return createTypedComparator(columnSchema.logicalType, collationFunc);
-		});
-
-		const keyFromRow = (row: Row): BTreeKeyForIndex => {
-			return localSpecColumns.map(sc => {
-				this.validateRowLength(row, sc.index);
-				return row[sc.index];
-			});
-		};
-
-		const compareKeys = (a: BTreeKeyForIndex, b: BTreeKeyForIndex): number => {
-			const arrA = a as SqlValue[];
-			const arrB = b as SqlValue[];
-
-			for (let i = 0; i < localSpecColumns.length; i++) {
-				if (i >= arrA.length || i >= arrB.length) {
-					return arrA.length - arrB.length;
-				}
-
-				const specCol = localSpecColumns[i];
-				const comparison = comparators[i](arrA[i], arrB[i]);
-
-				if (comparison !== 0) {
-					return specCol.desc ? -comparison : comparison;
-				}
-			}
-			return 0;
-		};
-
-		return { keyFromRow, compareKeys };
-	}
-
-	private validateRowLength(row: Row, columnIndex: number): void {
-		if (columnIndex < 0 || columnIndex >= row.length) {
-			quereusError(`Index key col index ${columnIndex} OOB for row len ${row.length}`, StatusCode.INTERNAL);
-		}
-	}
-
-	private createBTree(baseInheritreeTable?: BTree<BTreeKeyForIndex, MemoryIndexEntry>): BTree<BTreeKeyForIndex, MemoryIndexEntry> {
-		return new BTree<BTreeKeyForIndex, MemoryIndexEntry>(
-			(entry: MemoryIndexEntry) => entry.indexKey,
-			this.compareKeys,
-			baseInheritreeTable
-		);
-	}
-
-	/** Adds a mapping from index key to primary key */
-	addEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
-		const path = this.data.find(indexKey);
-		if (path.on) {
-			// Entry exists, add to the existing set of primary keys
-			const existingEntry = this.data.at(path)!;
-			existingEntry.primaryKeys.add(primaryKey);
-		} else {
-			// Create new entry with a Set containing the primary key
-			const newEntry: MemoryIndexEntry = {
-				indexKey,
-				primaryKeys: new Set([primaryKey])
-			};
-			this.data.insert(newEntry);
-		}
-	}
-
-	/** Removes a mapping from index key to primary key */
-	removeEntry(indexKey: BTreeKeyForIndex, primaryKey: BTreeKeyForPrimary): void {
-		const path = this.data.find(indexKey);
-		if (path.on) {
-			const entry = this.data.at(path)!;
-			entry.primaryKeys.delete(primaryKey);
-
-			// If no primary keys remain, remove the entire entry
-			if (entry.primaryKeys.size === 0) {
-				this.data.deleteAt(path);
-			}
-		}
-	}
-
-	/** Returns the primary keys for a given index key */
-	getPrimaryKeys(indexKey: BTreeKeyForIndex): BTreeKeyForPrimary[] {
-		const entry = this.data.get(indexKey);
-		return entry ? Array.from(entry.primaryKeys) : [];
-	}
-
-	/** Gets the count of unique index values */
-	get size(): number {
-		return this.data.getCount();
-	}
-
-	/** Clears all entries from the index */
-	clear(): void {
-		const base = (this.data as any).baseTable as BTree<BTreeKeyForIndex, MemoryIndexEntry> | undefined;
-		this.data = this.createBTree(base);
-	}
-
-	/** Clears the base inheritance for this index (used during layer collapse) */
-	clearBase(): void {
-		if (typeof (this.data as any).clearBase === 'function') {
-			(this.data as any).clearBase();
-		}
-	}
-}

package/src/vtab/memory/layer/base-cursor.ts

@@ -1,124 +0,0 @@
-import type { ScanPlan } from './scan-plan.js';
-import type { BaseLayer } from './base.js';
-import type { BTreeKey, BTreeKeyForPrimary, BTreeKeyForIndex } from '../types.js';
-import { IndexConstraintOp } from '../../../common/constants.js';
-import { compareSqlValues } from '../../../util/comparison.js';
-import { StatusCode, type Row } from '../../../common/types.js';
-import { safeIterate } from './safe-iterate.js';
-import { QuereusError } from '../../../common/errors.js';
-
-export async function* scanBaseLayer(
-	layer: BaseLayer,
-	plan: ScanPlan
-): AsyncIterable<Row> {
-	const { primaryKeyExtractorFromRow: keyFromEntry, primaryKeyComparator } = layer.getPkExtractorsAndComparators(layer.getSchema());
-	const isEqPlan = plan.equalityKey !== undefined;
-
-	const planAppliesToKey = (key: BTreeKey, keyIsIndexKey: boolean): boolean => {
-		const comparator = keyIsIndexKey
-			? layer.secondaryIndexes.get(plan.indexName)?.compareKeys
-			: primaryKeyComparator;
-		if (!comparator) return true;
-
-		if (plan.equalityKey !== undefined) return comparator(key, plan.equalityKey) === 0;
-
-		const keyForBoundComparison = Array.isArray(key) ? key[0] : key;
-		if (plan.lowerBound && (keyForBoundComparison !== undefined && keyForBoundComparison !== null)) {
-			const cmp = compareSqlValues(keyForBoundComparison, plan.lowerBound.value);
-			if (cmp < 0 || (cmp === 0 && plan.lowerBound.op === IndexConstraintOp.GT)) return false;
-		}
-		if (plan.upperBound && (keyForBoundComparison !== undefined && keyForBoundComparison !== null)) {
-			const cmp = compareSqlValues(keyForBoundComparison, plan.upperBound.value);
-			if (cmp > 0 || (cmp === 0 && plan.upperBound.op === IndexConstraintOp.LT)) return false;
-		}
-		return true;
-	};
-
-	if (plan.indexName === 'primary') {
-		const tree = layer.primaryTree; // BTree<BTreeKeyForPrimary, PrimaryModificationValue> from inheritree
-
-		if (isEqPlan && plan.equalityKey !== undefined) {
-			const value = tree.get(plan.equalityKey as BTreeKeyForPrimary);
-			if (value && planAppliesToKey(plan.equalityKey as BTreeKeyForPrimary, false)) {
-				yield value as Row;
-			}
-			return;
-		}
-
-		// Determine start key for range scans
-		let startKey: { value: BTreeKeyForPrimary } | undefined;
-		if (plan.lowerBound) {
-			startKey = { value: plan.lowerBound.value as BTreeKeyForPrimary };
-		}
-
-		// Create mutation-safe iterator with range support
-		for await (const value of safeIterate(tree, !plan.descending, startKey)) {
-			const row = value as Row;
-			const primaryKey = keyFromEntry(row);
-			if (!planAppliesToKey(primaryKey, false)) {
-				// If we're doing an ascending scan and we've passed the upper bound, we can break early
-				if (!plan.descending && plan.upperBound) {
-					const keyForComparison = Array.isArray(primaryKey) ? primaryKey[0] : primaryKey;
-					const cmp = compareSqlValues(keyForComparison, plan.upperBound.value);
-					if (cmp > 0 || (cmp === 0 && plan.upperBound.op === IndexConstraintOp.LT)) {
-						break;
-					}
-				}
-				continue;
-			}
-			yield row;
-		}
-	} else { // Secondary Index Scan
-		const secondaryIndex = layer.secondaryIndexes.get(plan.indexName);
-		if (!secondaryIndex) throw new QuereusError(`Secondary index '${plan.indexName}' not found in BaseLayer.`, StatusCode.INTERNAL);
-
-		const indexTree = secondaryIndex.data; // BTree<BTreeKeyForIndex, MemoryIndexEntry> from inheritree
-
-		if (isEqPlan && plan.equalityKey !== undefined) {
-			const indexEntry = indexTree.get(plan.equalityKey as BTreeKeyForIndex);
-			if (indexEntry && planAppliesToKey(indexEntry.indexKey, true)) {
-				for (const pk of indexEntry.primaryKeys) {
-					const value = layer.primaryTree.get(pk);
-					if (value) {
-						yield value as Row;
-					}
-				}
-			}
-			return;
-		}
-
-		// Use mutation-safe iterator for secondary index iteration with range support
-		const isAscending = !plan.descending;
-
-		// Determine start key for range scans on secondary index
-		let startKey: { value: BTreeKeyForIndex } | undefined;
-		if (plan.lowerBound) {
-			startKey = { value: plan.lowerBound.value as BTreeKeyForIndex };
-		}
-
-		for await (const indexEntry of safeIterate(indexTree, isAscending, startKey)) {
-			if (!planAppliesToKey(indexEntry.indexKey, true)) {
-				// Early termination for ascending scans past upper bound
-				if (isAscending && plan.upperBound) {
-					const keyForComparison = Array.isArray(indexEntry.indexKey) ? indexEntry.indexKey[0] : indexEntry.indexKey;
-					const cmp = compareSqlValues(keyForComparison, plan.upperBound.value);
-					if (cmp > 0 || (cmp === 0 && plan.upperBound.op === IndexConstraintOp.LT)) {
-						break;
-					}
-				}
-				continue;
-			}
-			for (const pk of indexEntry.primaryKeys) {
-				const value = layer.primaryTree.get(pk);
-				if (value) {
-					yield value as Row;
-				}
-			}
-		}
-	}
-}
-
-// LayerCursorInternal interface is removed as this file now exports an async generator.
-// If TransactionLayerCursorInternal needs a common interface with this for its parentCursor,
-// that interface would describe an AsyncIterable<Row> with perhaps getCurrentPrimaryKey() if still needed.
-// For now, let parentCursor in TransactionLayerCursorInternal be AsyncIterable<Row>.

package/src/vtab/memory/layer/base.ts

@@ -1,275 +0,0 @@
-import { BTree } from 'inheritree';
-import type { TableSchema } from '../../../schema/table.js';
-import type { BTreeKeyForPrimary, BTreeKeyForIndex, MemoryIndexEntry } from '../types.js';
-import type { Layer } from './interface.js';
-import { MemoryIndex } from '../index.js';
-import { safeJsonStringify } from '../../../util/serialization.js';
-import type { Row, SqlValue } from '../../../common/types.js';
-import { type ColumnSchema } from '../../../schema/column.js';
-import type { IndexSchema } from '../../../schema/table.js';
-import { createPrimaryKeyFunctions, type PrimaryKeyFunctions } from '../utils/primary-key.js';
-import { createMemoryTableLoggers } from '../utils/logging.js';
-
-let baseLayerCounter = 0;
-const logger = createMemoryTableLoggers('layer:base');
-
-export class BaseLayer implements Layer {
-	private readonly layerId: number;
-	public tableSchema: TableSchema;
-	private primaryKeyFunctions!: PrimaryKeyFunctions;
-	public primaryTree: BTree<BTreeKeyForPrimary, Row>;
-	public readonly secondaryIndexes: Map<string, MemoryIndex>;
-
-	constructor(schema: TableSchema) {
-		this.layerId = baseLayerCounter++;
-		this.tableSchema = schema;
-		this.initializePrimaryKeyFunctions();
-
-		// Use the same key extraction pattern as TransactionLayer for consistency
-		const btreeKeyFromValue = (value: Row): BTreeKeyForPrimary =>
-			this.primaryKeyFunctions.extractFromRow(value);
-
-		this.primaryTree = new BTree<BTreeKeyForPrimary, Row>(
-			btreeKeyFromValue,
-			this.primaryKeyFunctions.compare
-		);
-		this.secondaryIndexes = new Map();
-		this.rebuildAllSecondaryIndexes();
-	}
-
-	public updateSchema(newSchema: TableSchema): void {
-		logger.operation('Schema Update', this.tableSchema.name, {
-			from: this.tableSchema.name,
-			to: newSchema.name
-		});
-		this.tableSchema = newSchema;
-		this.initializePrimaryKeyFunctions();
-	}
-
-	private initializePrimaryKeyFunctions(): void {
-		this.primaryKeyFunctions = createPrimaryKeyFunctions(this.tableSchema);
-	}
-
-	public rebuildAllSecondaryIndexes(): void {
-		this.clearExistingSecondaryIndexes();
-
-		if (!this.hasSecondaryIndexes()) {
-			return;
-		}
-
-		const newIndexes = this.createSecondaryIndexes();
-		this.populateSecondaryIndexes(newIndexes);
-		this.replaceSecondaryIndexes(newIndexes);
-	}
-
-	private clearExistingSecondaryIndexes(): void {
-		this.secondaryIndexes.forEach(index => index.clear());
-	}
-
-	private hasSecondaryIndexes(): boolean {
-		return Boolean(this.tableSchema.indexes && this.tableSchema.indexes.length > 0);
-	}
-
-	private createSecondaryIndexes(): Map<string, MemoryIndex> {
-		const newIndexes = new Map<string, MemoryIndex>();
-
-		for (const indexSchema of this.tableSchema.indexes!) {
-			try {
-				const memoryIndex = new MemoryIndex(indexSchema, this.tableSchema.columns);
-				newIndexes.set(indexSchema.name, memoryIndex);
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			} catch (e: any) {
-				logger.error('Create Index', this.tableSchema.name, e, { indexName: indexSchema.name });
-			}
-		}
-
-		return newIndexes;
-	}
-
-	private populateSecondaryIndexes(newIndexes: Map<string, MemoryIndex>): void {
-		for (const path of this.primaryTree.ascending(this.primaryTree.first())) {
-			const row = this.primaryTree.at(path)!;
-			this.addRowToSecondaryIndexes(row, newIndexes);
-		}
-	}
-
-	private addRowToSecondaryIndexes(row: Row, indexes: Map<string, MemoryIndex>): void {
-		const primaryKey = this.primaryKeyFunctions.extractFromRow(row);
-
-		indexes.forEach(index => {
-			try {
-				const indexKey = index.keyFromRow(row);
-				index.addEntry(indexKey, primaryKey);
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			} catch (e: any) {
-				logger.error('Re-index Row', this.tableSchema.name, e, { indexName: index.name });
-			}
-		});
-	}
-
-	private replaceSecondaryIndexes(newIndexes: Map<string, MemoryIndex>): void {
-		this.secondaryIndexes.clear();
-		newIndexes.forEach((idx, name) => this.secondaryIndexes.set(name, idx));
-	}
-
-	getLayerId = (): number => this.layerId;
-	getParent = (): Layer | null => null;
-	getSchema = (): TableSchema => this.tableSchema;
-	isCommitted = (): boolean => true;
-
-	getModificationTree = (indexName: string | 'primary'): BTree<BTreeKeyForPrimary, Row> | null =>
-		indexName === 'primary' ? this.primaryTree : null;
-
-	getSecondaryIndexTree = (indexName: string): BTree<BTreeKeyForIndex, MemoryIndexEntry> | null =>
-		this.secondaryIndexes.get(indexName)?.data ?? null;
-
-	public getPkExtractorsAndComparators(schema: TableSchema): {
-		primaryKeyExtractorFromRow: (row: Row) => BTreeKeyForPrimary;
-		primaryKeyComparator: (a: BTreeKeyForPrimary, b: BTreeKeyForPrimary) => number
-	} {
-		if (schema !== this.tableSchema) {
-			logger.warn('PK Extractors', this.tableSchema.name, 'Called with different schema');
-		}
-		return {
-			primaryKeyExtractorFromRow: this.primaryKeyFunctions.extractFromRow,
-			primaryKeyComparator: this.primaryKeyFunctions.compare
-		};
-	}
-
-	applyChange(
-		primaryKey: BTreeKeyForPrimary,
-		modification: Row,
-		secondaryIndexChanges: Map<string, Array<{op: 'ADD' | 'DELETE', indexKey: BTreeKeyForIndex}>>
-	): void {
-		this.applySecondaryIndexChanges(primaryKey, secondaryIndexChanges);
-		this.applyPrimaryChange(primaryKey, modification);
-	}
-
-	private applySecondaryIndexChanges(
-		primaryKey: BTreeKeyForPrimary,
-		secondaryIndexChanges: Map<string, Array<{op: 'ADD' | 'DELETE', indexKey: BTreeKeyForIndex}>>
-	): void {
-		secondaryIndexChanges.forEach((changes, indexName) => {
-			const memoryIndex = this.secondaryIndexes.get(indexName);
-			if (!memoryIndex) {
-				logger.warn('Apply Change', this.tableSchema.name, 'Secondary index not found', {
-					indexName,
-					primaryKey: safeJsonStringify(primaryKey)
-				});
-				return;
-			}
-
-			changes.forEach(change => {
-				if (change.op === 'DELETE') {
-					memoryIndex.removeEntry(change.indexKey, primaryKey);
-				} else {
-					memoryIndex.addEntry(change.indexKey, primaryKey);
-				}
-			});
-		});
-	}
-
-	private applyPrimaryChange(primaryKey: BTreeKeyForPrimary, modification: Row): void {
-		this.primaryTree.insert(modification);
-	}
-
-	has = (key: BTreeKeyForPrimary): boolean => {
-		const value = this.primaryTree.get(key);
-		return value !== undefined;
-	};
-
-	async addColumnToBase(newColumnSchema: ColumnSchema, defaultValue: SqlValue): Promise<void> {
-		logger.operation('Add Column', this.tableSchema.name, {
-			columnName: newColumnSchema.name,
-			defaultValue
-		});
-
-		const oldPrimaryTree = this.primaryTree;
-
-		// First, reinitialize primary key functions with the updated schema (which already includes the new column)
-		this.initializePrimaryKeyFunctions();
-
-		// Create new primary tree with the updated schema and migrate data
-		this.recreatePrimaryTreeWithNewColumn(oldPrimaryTree, defaultValue);
-
-		this.rebuildAllSecondaryIndexes();
-	}
-
-	private recreatePrimaryTreeWithNewColumn(
-		oldTree: BTree<BTreeKeyForPrimary, Row>,
-		defaultValue: SqlValue
-	): void {
-		// Use the updated primary key functions for the new tree
-		const btreeKeyFromValue = (value: Row): BTreeKeyForPrimary =>
-			this.primaryKeyFunctions.extractFromRow(value);
-
-		this.primaryTree = new BTree<BTreeKeyForPrimary, Row>(
-			btreeKeyFromValue,
-			this.primaryKeyFunctions.compare
-		);
-
-		for (const path of oldTree.ascending(oldTree.first())) {
-			const oldRow = oldTree.at(path)!;
-			const newRow = [...oldRow, defaultValue];
-			this.primaryTree.insert(newRow);
-		}
-	}
-
-	async dropColumnFromBase(columnIndexInOldSchema: number): Promise<void> {
-		logger.operation('Drop Column', this.tableSchema.name, {
-			columnIndex: columnIndexInOldSchema
-		});
-
-		const oldPrimaryTree = this.primaryTree;
-		this.recreatePrimaryTreeWithoutColumn(oldPrimaryTree, columnIndexInOldSchema);
-		await this.rebuildAllSecondaryIndexes();
-	}
-
-	private recreatePrimaryTreeWithoutColumn(oldTree: BTree<BTreeKeyForPrimary, Row>, columnIndex: number): void {
-		const btreeKeyFromValue = (value: Row): BTreeKeyForPrimary =>
-			this.primaryKeyFunctions.extractFromRow(value);
-
-		this.primaryTree = new BTree<BTreeKeyForPrimary, Row>(
-			btreeKeyFromValue,
-			this.primaryKeyFunctions.compare
-		);
-
-		for (const path of oldTree.ascending(oldTree.first())) {
-			const oldRow = oldTree.at(path)!;
-			const newRow = oldRow.filter((_, idx) => idx !== columnIndex);
-			this.primaryTree.insert(newRow);
-		}
-	}
-
-	async handleColumnRename(): Promise<void> {
-		logger.operation('Handle Column Rename', this.tableSchema.name);
-		await this.rebuildAllSecondaryIndexes();
-	}
-
-	async addIndexToBase(indexSchema: IndexSchema): Promise<void> {
-		logger.operation('Add Index', this.tableSchema.name, {
-			indexName: indexSchema.name
-		});
-
-		const newMemoryIndex = new MemoryIndex(indexSchema, this.tableSchema.columns);
-		this.populateNewIndex(newMemoryIndex);
-		this.secondaryIndexes.set(indexSchema.name, newMemoryIndex);
-	}
-
-	private populateNewIndex(newIndex: MemoryIndex): void {
-		for (const path of this.primaryTree.ascending(this.primaryTree.first())) {
-			const currentRow = this.primaryTree.at(path)!;
-			const indexKey = newIndex.keyFromRow(currentRow);
-			const primaryKey = this.primaryKeyFunctions.extractFromRow(currentRow);
-			newIndex.addEntry(indexKey, primaryKey);
-		}
-	}
-
-	async dropIndexFromBase(indexName: string): Promise<void> {
-		if (this.secondaryIndexes.delete(indexName)) {
-			logger.operation('Drop Index', this.tableSchema.name, { indexName });
-		} else {
-			logger.warn('Drop Index', this.tableSchema.name, 'Index not found', { indexName });
-		}
-	}
-}