address comments

src/btree/multi.ts

@@ -3,11 +3,13 @@ import { MemoryPointer } from "./node";
 import { PageFile } from "./pagefile";
 
 const PAGE_SIZE_BYTES = 4096;
+export const maxUint64 = 2n ** 64n - 1n;
 
 export class LinkedMetaPage {
 	private resolver: RangeResolver;
 	private offset: bigint;
 	private metaPageData: ArrayBuffer | null;
+	private metaPagePromise: Promise<ArrayBuffer> | null = null;
 
 	constructor(resolver: RangeResolver, offset: bigint) {
 		this.resolver = resolver;
@@ -57,14 +59,23 @@ export class LinkedMetaPage {
 			return this.metaPageData;
 		}
 
-		const { data } = await this.resolver({
-			start: Number(this.offset),
-			end: Number(this.offset) + PAGE_SIZE_BYTES - 1,
-		});
-
-		this.metaPageData = data;
+		if (!this.metaPagePromise) {
+			this.metaPagePromise = this.resolver({
+				start: Number(this.offset),
+				end: Number(this.offset) + PAGE_SIZE_BYTES - 1,
+			})
+				.then(({ data }) => {
+					this.metaPageData = data;
+					this.metaPagePromise = null;
+					return data;
+				})
+				.catch((error) => {
+					this.metaPagePromise = null;
+					throw error;
+				});
+		}
 
-		return data;
+		return this.metaPagePromise;
 	}
 
 	/**
@@ -75,7 +86,7 @@ export class LinkedMetaPage {
 
 		const view = new DataView(pageData, 12, 8);
 		const nextOffset = view.getBigUint64(0);
-		const maxUint64 = 2n ** 64n - 1n;
+
 		if (nextOffset === maxUint64) {
 			return null;
 		}

src/db/database.ts

@@ -28,10 +28,14 @@ export type Query<T extends Schema> = {
 };
 
 export enum FieldType {
-	String = 1 << 0,
-	Number = 1 << 1,
-	Boolean = 1 << 4,
-	Null = 1 << 5,
+	String = 0,
+	Int64 = 1,
+	Uint64 = 2,
+	Float64 = 3,
+	Object = 4,
+	Array = 5,
+	Boolean = 6,
+	Null = 7,
 }
 
 function parseIgnoringSuffix(

src/db/query-validation.ts

@@ -1,4 +1,4 @@
-import { IndexMeta } from "../index-file/meta";
+import { IndexHeader, IndexMeta } from "../index-file/meta";
 import {
 	FieldType,
 	OrderBy,
@@ -16,8 +16,8 @@ import {
  * @param {FieldType} singleType - The specific type to check for within the compositeType.
  * @returns {boolean} - Returns true if singleType is included in compositeType, false otherwise.
  */
-function containsType(compositeType: bigint, singleType: FieldType): boolean {
-	return (compositeType & BigInt(singleType)) !== BigInt(0);
+function containsType(compositeType: number[], singleType: number): boolean {
+	return compositeType.includes(singleType);	
 }
 
 /**
@@ -29,7 +29,7 @@ function containsType(compositeType: bigint, singleType: FieldType): boolean {
  */
 function validateWhere<T extends Schema>(
 	where: WhereNode<T>[] | undefined,
-	headers: IndexMeta[]
+	headers: IndexHeader[]
 ): void {
 	if (!where || !Array.isArray(where) || where.length === 0) {
 		throw new Error("Missing 'where' clause.");
@@ -57,27 +57,27 @@ function validateWhere<T extends Schema>(
 			throw new Error("'value' in 'where' clause is missing.");
 		}
 
-		const headerType = header.fieldType;
+		const headerType = header.fieldTypes;
 
 		if (whereNode.value === null) {
-			if (!containsType(headerType, FieldType.Null)) {
+			if (!containsType(headerType, 7)) {
 				throw new Error(`'key: ${whereNode.key} does not have type: null.`);
 			}
 		} else {
 			function fieldTypeError(
 				key: string,
 				actual: FieldType,
-				expected: bigint
+				expected: number[] 
 			): string {
 				return `key: ${key} does not have type: ${actual}. Expected: ${expected}`;
 			}
 
 			switch (typeof whereNode.value) {
 				case "bigint":
 				case "number":
-					if (!containsType(headerType, FieldType.Number)) {
+					if (!containsType(headerType, FieldType.Int64)) {
 						throw new Error(
-							fieldTypeError(whereNode.key, FieldType.Number, headerType)
+							fieldTypeError(whereNode.key, FieldType.Int64, headerType)
 						);
 					}
 					break;
@@ -141,7 +141,7 @@ function validateOrderBy<T extends Schema>(
  */
 function validateSelect<T extends Schema>(
 	select: SelectField<T>[] | undefined,
-	headers: IndexMeta[]
+	headers: IndexHeader[]
 ): void {
 	if (select) {
 		if (!Array.isArray(select) || select.length === 0) {
@@ -171,7 +171,7 @@ function validateSelect<T extends Schema>(
  */
 export async function validateQuery<T extends Schema>(
 	query: Query<T>,
-	headers: IndexMeta[]
+	headers: IndexHeader[]
 ): Promise<void> {
 	validateWhere(query.where, headers);
 	validateOrderBy(query.orderBy, query.where![0].key as string);

src/index-file/index-file.ts

@@ -74,35 +74,24 @@ export class IndexFileV1<T> implements VersionedIndexFile<T> {
 		const buffer = await tree.metadata();
 
 		// unmarshall binary for FileMeta
-		if (buffer.byteLength < 9) {
+		if (buffer.byteLength < 10) {
 			throw new Error(`incorrect byte length! Want: 10, got ${buffer.byteLength}`);
 		}
 
 		const dataView = new DataView(buffer);
 		const version = dataView.getUint8(0);
 		const formatByte = dataView.getUint8(1);
 
-		let format;
-		switch (formatByte) {
-			case FileFormat.CSV:
-				format = FileFormat.CSV
-				break
-			case FileFormat.JSONL:
-				format = FileFormat.JSONL
-				break
-			default:
-				throw new Error(`invalid format: ${formatByte}`)
-		}
 
-		if (format !== FileFormat.CSV && format !== FileFormat.JSONL) {
-			throw new Error(`unexpected file format. Got: ${format}`);
+		if (Object.values(FileFormat).indexOf(formatByte) === -1) {
+			throw new Error(`unexpected file format. Got: ${formatByte}`);
 		}
 
 		const readOffset = dataView.getBigUint64(2);
 
 		return {
 			version: version,
-			format: format,
+			format: formatByte,
 			readOffset: readOffset,
 		};
 	}

src/index-file/meta.ts

@@ -20,17 +20,18 @@ export async function readFileMeta(buffer: ArrayBuffer): Promise<FileMeta> {
 	const dataView = new DataView(buffer);
 
 	const version = dataView.getUint8(0);
-	const format = dataView.getUint8(1);
+	const formatByte = dataView.getUint8(1);
 
-	if (format !== FileFormat.CSV && format !== FileFormat.JSONL) {
-		throw new Error(`unexpected file format. Got: ${format}`);
+	if (Object.values(FileFormat).indexOf(formatByte) === -1) {
+		throw new Error(`unexpected file format. Got: ${formatByte}`);
 	}
 
+
 	const readOffset = dataView.getBigUint64(2);
 
 	return {
 		version,
-		format,
+		format: formatByte,
 		readOffset,
 	};
 }