documents.js 1.60.3 → 1.62.0

package/dist/firebird/data.js

@@ -25,23 +25,71 @@ var FirebirdCompositeRecordUnsupportedError = class extends Error {
 		this.recordType = recordType;
 	}
 };
-function skipBlobRecord(reader) {
-	let segmentCount;
+function readBlobRecord(reader) {
+	const ATT_BLOB_FIELD_NUMBER = 3;
+	const ATT_BLOB_NUMBER_SEGMENTS = 5;
+	const ATT_BLOB_DATA = 7;
+	let fieldNumber;
+	let segmentCount = 0;
 	for (;;) {
 		const attribute = reader.readTag();
-		if (attribute === 0) break;
-		if (attribute === 5) segmentCount = reader.readInt32Attribute();
-		else if (attribute === 7) {
-			const count = segmentCount ?? 0;
-			for (let i = 0; i < count; i++) {
-				const length = reader.readBlobSegmentLength();
-				reader.readRawPayload(length);
-			}
-		} else reader.skipAttributeValue();
+		if (attribute === ATT_BLOB_DATA) break;
+		if (attribute === ATT_BLOB_FIELD_NUMBER) fieldNumber = reader.readInt32Attribute();
+		else if (attribute === ATT_BLOB_NUMBER_SEGMENTS) segmentCount = reader.readInt32Attribute();
+		else reader.skipAttributeValue();
+	}
+	if (fieldNumber === void 0) throw new FirebirdDataParseError("a rec_blob record had no att_blob_field_number attribute, so its content cannot be attributed to a column");
+	const segments = [];
+	let total = 0;
+	for (let i = 0; i < segmentCount; i++) {
+		const length = reader.readBlobSegmentLength();
+		const segment = reader.readRawPayload(length);
+		segments.push(segment);
+		total += segment.length;
+	}
+	const bytes = new Uint8Array(total);
+	let offset = 0;
+	for (const segment of segments) {
+		bytes.set(segment, offset);
+		offset += segment.length;
 	}
+	return {
+		fieldNumber,
+		bytes
+	};
+}
+const BINARY_BLOB_DATA_URI_PREFIX = "data:application/octet-stream;base64,";
+const BLOB_SUB_TYPE_TEXT = 1;
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+	let result = "";
+	for (let i = 0; i < bytes.length; i += 3) {
+		const b0 = bytes[i] ?? 0;
+		const b1 = bytes[i + 1];
+		const b2 = bytes[i + 2];
+		const triple = b0 << 16 | (b1 ?? 0) << 8 | (b2 ?? 0);
+		result += BASE64_ALPHABET[triple >> 18 & 63] ?? "";
+		result += BASE64_ALPHABET[triple >> 12 & 63] ?? "";
+		result += b1 === void 0 ? "=" : BASE64_ALPHABET[triple >> 6 & 63] ?? "";
+		result += b2 === void 0 ? "=" : BASE64_ALPHABET[triple & 63] ?? "";
+	}
+	return result;
+}
+function blobCellValue(field, bytes) {
+	if (field.subType === BLOB_SUB_TYPE_TEXT) return {
+		kind: "string",
+		value: new TextDecoder("utf-8").decode(bytes)
+	};
+	return {
+		kind: "string",
+		value: `${BINARY_BLOB_DATA_URI_PREFIX}${bytesToBase64(bytes)}`
+	};
+}
+function storedFieldsOf(fields) {
+	return fields.filter((field) => !field.computed);
 }
 function decodeRowValues(fields, payload) {
-	const storedFields = fields.filter((field) => !field.computed);
+	const storedFields = storedFieldsOf(fields);
 	const xdr = new XdrReader(payload);
 	const rawValues = [];
 	for (const field of storedFields) switch (field.physicalType) {
@@ -170,10 +218,16 @@ function readRowGroup(reader, relation, compressed) {
 			if (dataTag !== ATT_DATA_DATA) throw new FirebirdDataParseError(`relation "${relation.name}": expected att_data_data (tag ${ATT_DATA_DATA}), found tag ${dataTag}`);
 		}
 		const payload = compressed ? reader.readCompressedPayload(xdrLength) : reader.readRawPayload(xdrLength);
-		rows.push(decodeRowValues(relation.fields, payload));
+		const values = decodeRowValues(relation.fields, payload);
+		rows.push(values);
 		let next = reader.readTag();
 		while (next === REC_BLOB) {
-			skipBlobRecord(reader);
+			const blob = readBlobRecord(reader);
+			const storedFields = storedFieldsOf(relation.fields);
+			const columnIndex = storedFields.findIndex((field) => field.fieldNumber === blob.fieldNumber);
+			const field = storedFields[columnIndex];
+			if (field === void 0) throw new FirebirdDataParseError(`relation "${relation.name}": a rec_blob record names att_blob_field_number ${blob.fieldNumber}, which matches no field's own att_field_number in this relation`);
+			values[columnIndex] = blobCellValue(field, blob.bytes);
 			next = reader.readTag();
 		}
 		if (next !== REC_DATA) {

package/dist/firebird/schema.cjs

@@ -12,8 +12,10 @@ var FirebirdSchemaParseError = class extends Error {
 const ATT_RELATION_NAME = 1;
 const ATT_FIELD_NAME = 1;
 const ATT_FIELD_TYPE = 8;
+const ATT_FIELD_SUB_TYPE = 9;
 const ATT_FIELD_LENGTH = 10;
 const ATT_FIELD_SCALE = 11;
+const ATT_FIELD_NUMBER = 22;
 const ATT_FIELD_COMPUTED_FLAG = 23;
 const ATT_FIELD_CHARACTER_LENGTH = 41;
 function readField(reader) {
@@ -22,6 +24,8 @@ function readField(reader) {
 	let lengthBytes = 0;
 	let scale = 0;
 	let characterLength;
+	let subType = 0;
+	let fieldNumber;
 	let computed = false;
 	for (;;) {
 		const attribute = reader.readTag();
@@ -33,9 +37,15 @@ function readField(reader) {
 			case ATT_FIELD_TYPE:
 				blrType = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_SUB_TYPE:
+				subType = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_LENGTH:
 				lengthBytes = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_NUMBER:
+				fieldNumber = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_SCALE:
 				scale = reader.readInt32Attribute();
 				break;
@@ -51,13 +61,15 @@ function readField(reader) {
 	if (name === void 0) throw new FirebirdSchemaParseError("a rec_field record had no att_field_name attribute");
 	if (blrType === void 0) throw new FirebirdSchemaParseError(`field "${name}" had no att_field_type attribute`);
 	const physicalType = require_firebird_blr_types.decodeBlrType(blrType);
-	const typeLabel = require_firebird_blr_types.describeFieldType(physicalType, lengthBytes, scale, characterLength);
+	const typeLabel = require_firebird_blr_types.describeFieldType(physicalType, lengthBytes, scale, characterLength, subType);
 	return {
 		name,
 		physicalType,
 		lengthBytes,
 		scale,
 		characterLength,
+		subType,
+		fieldNumber,
 		typeLabel,
 		computed
 	};

package/dist/firebird/schema.d.cts

@@ -1,2 +1,2 @@
-import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-Acco3Ezi.cjs";
+import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-BeR_KJ0X.cjs";
 export { FirebirdField, FirebirdRelation, FirebirdSchemaParseError, readRelationSchema };

package/dist/firebird/schema.d.ts

@@ -1,2 +1,2 @@
-import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-VkAA6pF5.js";
+import { i as readRelationSchema, n as FirebirdRelation, r as FirebirdSchemaParseError, t as FirebirdField } from "../schema-CSKwSb_v.js";
 export { FirebirdField, FirebirdRelation, FirebirdSchemaParseError, readRelationSchema };

package/dist/firebird/schema.js

@@ -11,8 +11,10 @@ var FirebirdSchemaParseError = class extends Error {
 const ATT_RELATION_NAME = 1;
 const ATT_FIELD_NAME = 1;
 const ATT_FIELD_TYPE = 8;
+const ATT_FIELD_SUB_TYPE = 9;
 const ATT_FIELD_LENGTH = 10;
 const ATT_FIELD_SCALE = 11;
+const ATT_FIELD_NUMBER = 22;
 const ATT_FIELD_COMPUTED_FLAG = 23;
 const ATT_FIELD_CHARACTER_LENGTH = 41;
 function readField(reader) {
@@ -21,6 +23,8 @@ function readField(reader) {
 	let lengthBytes = 0;
 	let scale = 0;
 	let characterLength;
+	let subType = 0;
+	let fieldNumber;
 	let computed = false;
 	for (;;) {
 		const attribute = reader.readTag();
@@ -32,9 +36,15 @@ function readField(reader) {
 			case ATT_FIELD_TYPE:
 				blrType = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_SUB_TYPE:
+				subType = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_LENGTH:
 				lengthBytes = reader.readInt32Attribute();
 				break;
+			case ATT_FIELD_NUMBER:
+				fieldNumber = reader.readInt32Attribute();
+				break;
 			case ATT_FIELD_SCALE:
 				scale = reader.readInt32Attribute();
 				break;
@@ -50,13 +60,15 @@ function readField(reader) {
 	if (name === void 0) throw new FirebirdSchemaParseError("a rec_field record had no att_field_name attribute");
 	if (blrType === void 0) throw new FirebirdSchemaParseError(`field "${name}" had no att_field_type attribute`);
 	const physicalType = decodeBlrType(blrType);
-	const typeLabel = describeFieldType(physicalType, lengthBytes, scale, characterLength);
+	const typeLabel = describeFieldType(physicalType, lengthBytes, scale, characterLength, subType);
 	return {
 		name,
 		physicalType,
 		lengthBytes,
 		scale,
 		characterLength,
+		subType,
+		fieldNumber,
 		typeLabel,
 		computed
 	};

package/dist/{geometry-DvwdrIij.d.cts → geometry-DaJr8yQW.d.cts}

@@ -1,5 +1,5 @@
-import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
+import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize as PageSize$1, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
 //#region src/model/geometry.d.ts
 declare function flipY(box: Box, containerHeightPt: number): Box;
 //#endregion
-export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };
+export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize$1 as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };

package/dist/{geometry-DvwdrIij.d.ts → geometry-DaJr8yQW.d.ts}

@@ -1,5 +1,5 @@
-import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
+import { Box, Box as Box$1, BoxSchema, Margins, MarginsSchema, PAGE_SIZE_A4, PAGE_SIZE_LETTER, PageSize as PageSize$1, PageSizeSchema, SLIDE_SIZE_STANDARD, SLIDE_SIZE_WIDESCREEN } from "document-schema.js";
 //#region src/model/geometry.d.ts
 declare function flipY(box: Box, containerHeightPt: number): Box;
 //#endregion
-export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };
+export { PAGE_SIZE_A4 as a, PageSizeSchema as c, flipY as d, MarginsSchema as i, SLIDE_SIZE_STANDARD as l, BoxSchema as n, PAGE_SIZE_LETTER as o, Margins as r, PageSize$1 as s, Box$1 as t, SLIDE_SIZE_WIDESCREEN as u };

package/dist/hsqldb/binary-script.cjs

@@ -0,0 +1,154 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_hsqldb_script = require("./script.cjs");
+const require_hsqldb_rowformat = require("./rowformat.cjs");
+let fflate = require("fflate");
+//#region src/hsqldb/binary-script.ts
+var HsqldbBinaryScriptParseError = class extends Error {
+	offset;
+	constructor(message, offset) {
+		super(`HSQLDB binary script parse error at byte offset ${offset}: ${message}`);
+		this.name = "HsqldbBinaryScriptParseError";
+		this.offset = offset;
+	}
+};
+const RESULT_MODE_DATA = 3;
+const SQL_TYPE_VARCHAR = 12;
+const TABLE_INIT_WITH_SCHEMA = 1;
+const TABLE_INIT_WITHOUT_SCHEMA = 0;
+var BinaryScriptCursor = class {
+	cursor;
+	length;
+	constructor(bytes) {
+		this.cursor = new require_hsqldb_rowformat.HsqldbDataCursor(bytes);
+		this.length = bytes.length;
+	}
+	get position() {
+		return this.cursor.position;
+	}
+	set position(value) {
+		this.cursor.position = value;
+	}
+	hasRecordLength() {
+		return this.cursor.position + 4 <= this.length;
+	}
+	require(byteCount, what) {
+		if (this.cursor.position + byteCount > this.length) throw new HsqldbBinaryScriptParseError(`stream ends after ${this.length} bytes while reading ${what} (${byteCount} byte(s) needed)`, this.cursor.position);
+	}
+	readInt32(what) {
+		this.require(4, what);
+		return this.cursor.readInt32();
+	}
+	readInt16(what) {
+		this.require(2, what);
+		return this.cursor.readInt16();
+	}
+	readString(what) {
+		const byteLength = this.readInt32(`${what}'s own length prefix`);
+		if (byteLength < 0) throw new HsqldbBinaryScriptParseError(`${what} declares a negative length ${byteLength}`, this.cursor.position);
+		this.require(byteLength, what);
+		return require_hsqldb_rowformat.readModifiedUtf8(this.cursor.readBytes(byteLength));
+	}
+};
+function readResultMetaData(reader) {
+	const columnCount = reader.readInt32("the DDL result's own column count");
+	if (columnCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative column count ${columnCount}`, reader.position);
+	const columnTypes = [];
+	for (let i = 0; i < columnCount; i++) {
+		columnTypes.push(reader.readInt16(`column ${i}'s own SQL type`));
+		reader.readInt32(`column ${i}'s own declared size`);
+		reader.readInt32(`column ${i}'s own declared scale`);
+		reader.readString(`column ${i}'s own label`);
+		const tableName = reader.readString(`column ${i}'s own table name`);
+		const columnName = reader.readString(`column ${i}'s own name`);
+		reader.readString(`column ${i}'s own class name`);
+		if (tableName.length > 0 && columnName.length > 0) {
+			reader.readInt32(`column ${i}'s own table-column attribute mask`);
+			reader.readString(`column ${i}'s own catalog name`);
+			reader.readString(`column ${i}'s own schema name`);
+		}
+	}
+	return columnTypes;
+}
+function readDdlStatements(reader) {
+	const recordStart = reader.position;
+	const recordLength = reader.readInt32("the leading DDL result record's own length");
+	if (recordLength <= 4) throw new HsqldbBinaryScriptParseError(`the leading DDL result record declares an implausible length ${recordLength} -- not a recognisable HSQLDB binary script`, recordStart);
+	const mode = reader.readInt32("the DDL result's own mode");
+	if (mode !== RESULT_MODE_DATA) throw new HsqldbBinaryScriptParseError(`the leading record has Result mode ${mode}, not the DATA mode (${RESULT_MODE_DATA}) a script's own DDL result always carries -- not a recognisable HSQLDB binary script`, recordStart);
+	reader.readInt32("the DDL result's own database id");
+	reader.readInt32("the DDL result's own session id");
+	const columnTypes = readResultMetaData(reader);
+	const firstColumnType = columnTypes[0];
+	if (columnTypes.length !== 1 || firstColumnType !== SQL_TYPE_VARCHAR) throw new HsqldbBinaryScriptParseError(`the DDL result has ${columnTypes.length} column(s) of type [${columnTypes.join(", ")}] -- a script's own DDL result is always the single VARCHAR "COMMAND" column DatabaseScript.getScript builds`, recordStart);
+	const rowCount = reader.readInt32("the DDL result's own row count");
+	if (rowCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative row count ${rowCount}`, reader.position);
+	const statements = [];
+	for (let i = 0; i < rowCount; i++) {
+		reader.require(1, `DDL statement ${i}`);
+		const value = require_hsqldb_rowformat.readHsqldbColumnValue(reader.cursor, SQL_TYPE_VARCHAR);
+		if (value.kind !== "string") throw new HsqldbBinaryScriptParseError(`DDL statement ${i} decoded as a ${value.kind} value rather than a string`, reader.position);
+		statements.push(value.value);
+	}
+	const recordEnd = recordStart + recordLength;
+	if (reader.position > recordEnd) throw new HsqldbBinaryScriptParseError(`the DDL result overran its own declared length (consumed ${reader.position - recordStart} bytes, declared ${recordLength})`, reader.position);
+	reader.position = recordEnd;
+	return statements;
+}
+function readTableSection(reader, tables, options) {
+	if (!reader.hasRecordLength()) return;
+	if (reader.readInt32("a table section's own init record length") === 0) return;
+	const tableName = reader.readString("a table section's own table name");
+	const schemaFlag = reader.readInt32(`table "${tableName}"'s own schema-presence flag`);
+	if (schemaFlag !== TABLE_INIT_WITH_SCHEMA && schemaFlag !== TABLE_INIT_WITHOUT_SCHEMA) throw new HsqldbBinaryScriptParseError(`table "${tableName}"'s init record has schema flag ${schemaFlag}, which is neither ${TABLE_INIT_WITHOUT_SCHEMA} nor ${TABLE_INIT_WITH_SCHEMA}`, reader.position);
+	if (schemaFlag === TABLE_INIT_WITH_SCHEMA) reader.readString(`table "${tableName}"'s own schema name`);
+	const table = tables.get(tableName.toUpperCase());
+	if (table === void 0) throw new HsqldbBinaryScriptParseError(`the data section declares rows for table "${tableName}", which the script's own DDL never declared`, reader.position);
+	const typeCodes = table.columns.map((column) => require_hsqldb_rowformat.resolveHsqldbTypeCode(column.type));
+	const rows = [];
+	for (;;) {
+		const rowStart = reader.position;
+		const rowLength = reader.readInt32(`a row length in table "${tableName}"`);
+		if (rowLength === 0) break;
+		if (rowLength < 0) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" declares a negative length ${rowLength}`, rowStart);
+		const rowEnd = rowStart + rowLength;
+		reader.require(rowLength - 4, `a row in table "${tableName}"`);
+		rows.push(typeCodes.map((typeCode) => require_hsqldb_rowformat.readHsqldbColumnValue(reader.cursor, typeCode, options)));
+		if (reader.position > rowEnd) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" overran its own declared length (consumed ${reader.position - rowStart} bytes, declared ${rowLength})`, reader.position);
+		reader.position = rowEnd;
+	}
+	const declaredRowCount = reader.readInt32(`table "${tableName}"'s own trailing row count`);
+	if (declaredRowCount !== rows.length) throw new HsqldbBinaryScriptParseError(`table "${tableName}" declares ${declaredRowCount} row(s) in its own terminator but the section carried ${rows.length}`, reader.position);
+	return {
+		tableName,
+		rows
+	};
+}
+function parseHsqldbBinaryScript(bytes, options) {
+	const reader = new BinaryScriptCursor(bytes);
+	const scriptText = readDdlStatements(reader).join("\n");
+	const tables = require_hsqldb_script.parseHsqldbScript(new TextEncoder().encode(scriptText));
+	const tablesByName = new Map(tables.map((table) => [table.tableName.toUpperCase(), table]));
+	const rowsByTable = /* @__PURE__ */ new Map();
+	for (;;) {
+		const section = readTableSection(reader, tablesByName, options);
+		if (section === void 0) break;
+		rowsByTable.set(section.tableName.toUpperCase(), section.rows);
+	}
+	return {
+		scriptText,
+		tables: tables.map((table) => {
+			const rows = rowsByTable.get(table.tableName.toUpperCase());
+			return rows === void 0 ? table : {
+				...table,
+				rows
+			};
+		})
+	};
+}
+function inflateHsqldbCompressedScript(bytes) {
+	return (0, fflate.unzlibSync)(bytes);
+}
+//#endregion
+exports.HsqldbBinaryScriptParseError = HsqldbBinaryScriptParseError;
+exports.inflateHsqldbCompressedScript = inflateHsqldbCompressedScript;
+exports.parseHsqldbBinaryScript = parseHsqldbBinaryScript;

package/dist/hsqldb/binary-script.d.cts

@@ -0,0 +1,15 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.cjs";
+import { HsqldbTable } from "./script.cjs";
+//#region src/hsqldb/binary-script.d.ts
+declare class HsqldbBinaryScriptParseError extends Error {
+  readonly offset: number;
+  constructor(message: string, offset: number);
+}
+interface HsqldbBinaryScript {
+  readonly scriptText: string;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function parseHsqldbBinaryScript(bytes: Uint8Array<ArrayBuffer>, options?: HsqldbDecodeOptions): HsqldbBinaryScript;
+declare function inflateHsqldbCompressedScript(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { HsqldbBinaryScript, HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/binary-script.d.ts

@@ -0,0 +1,15 @@
+import { n as HsqldbDecodeOptions } from "../rowformat-Cl2exlEh.js";
+import { HsqldbTable } from "./script.js";
+//#region src/hsqldb/binary-script.d.ts
+declare class HsqldbBinaryScriptParseError extends Error {
+  readonly offset: number;
+  constructor(message: string, offset: number);
+}
+interface HsqldbBinaryScript {
+  readonly scriptText: string;
+  readonly tables: readonly HsqldbTable[];
+}
+declare function parseHsqldbBinaryScript(bytes: Uint8Array<ArrayBuffer>, options?: HsqldbDecodeOptions): HsqldbBinaryScript;
+declare function inflateHsqldbCompressedScript(bytes: Uint8Array<ArrayBuffer>): Uint8Array<ArrayBuffer>;
+//#endregion
+export { HsqldbBinaryScript, HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/binary-script.js

@@ -0,0 +1,151 @@
+import { parseHsqldbScript } from "./script.js";
+import { HsqldbDataCursor, readHsqldbColumnValue, readModifiedUtf8, resolveHsqldbTypeCode } from "./rowformat.js";
+import { unzlibSync } from "fflate";
+//#region src/hsqldb/binary-script.ts
+var HsqldbBinaryScriptParseError = class extends Error {
+	offset;
+	constructor(message, offset) {
+		super(`HSQLDB binary script parse error at byte offset ${offset}: ${message}`);
+		this.name = "HsqldbBinaryScriptParseError";
+		this.offset = offset;
+	}
+};
+const RESULT_MODE_DATA = 3;
+const SQL_TYPE_VARCHAR = 12;
+const TABLE_INIT_WITH_SCHEMA = 1;
+const TABLE_INIT_WITHOUT_SCHEMA = 0;
+var BinaryScriptCursor = class {
+	cursor;
+	length;
+	constructor(bytes) {
+		this.cursor = new HsqldbDataCursor(bytes);
+		this.length = bytes.length;
+	}
+	get position() {
+		return this.cursor.position;
+	}
+	set position(value) {
+		this.cursor.position = value;
+	}
+	hasRecordLength() {
+		return this.cursor.position + 4 <= this.length;
+	}
+	require(byteCount, what) {
+		if (this.cursor.position + byteCount > this.length) throw new HsqldbBinaryScriptParseError(`stream ends after ${this.length} bytes while reading ${what} (${byteCount} byte(s) needed)`, this.cursor.position);
+	}
+	readInt32(what) {
+		this.require(4, what);
+		return this.cursor.readInt32();
+	}
+	readInt16(what) {
+		this.require(2, what);
+		return this.cursor.readInt16();
+	}
+	readString(what) {
+		const byteLength = this.readInt32(`${what}'s own length prefix`);
+		if (byteLength < 0) throw new HsqldbBinaryScriptParseError(`${what} declares a negative length ${byteLength}`, this.cursor.position);
+		this.require(byteLength, what);
+		return readModifiedUtf8(this.cursor.readBytes(byteLength));
+	}
+};
+function readResultMetaData(reader) {
+	const columnCount = reader.readInt32("the DDL result's own column count");
+	if (columnCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative column count ${columnCount}`, reader.position);
+	const columnTypes = [];
+	for (let i = 0; i < columnCount; i++) {
+		columnTypes.push(reader.readInt16(`column ${i}'s own SQL type`));
+		reader.readInt32(`column ${i}'s own declared size`);
+		reader.readInt32(`column ${i}'s own declared scale`);
+		reader.readString(`column ${i}'s own label`);
+		const tableName = reader.readString(`column ${i}'s own table name`);
+		const columnName = reader.readString(`column ${i}'s own name`);
+		reader.readString(`column ${i}'s own class name`);
+		if (tableName.length > 0 && columnName.length > 0) {
+			reader.readInt32(`column ${i}'s own table-column attribute mask`);
+			reader.readString(`column ${i}'s own catalog name`);
+			reader.readString(`column ${i}'s own schema name`);
+		}
+	}
+	return columnTypes;
+}
+function readDdlStatements(reader) {
+	const recordStart = reader.position;
+	const recordLength = reader.readInt32("the leading DDL result record's own length");
+	if (recordLength <= 4) throw new HsqldbBinaryScriptParseError(`the leading DDL result record declares an implausible length ${recordLength} -- not a recognisable HSQLDB binary script`, recordStart);
+	const mode = reader.readInt32("the DDL result's own mode");
+	if (mode !== RESULT_MODE_DATA) throw new HsqldbBinaryScriptParseError(`the leading record has Result mode ${mode}, not the DATA mode (${RESULT_MODE_DATA}) a script's own DDL result always carries -- not a recognisable HSQLDB binary script`, recordStart);
+	reader.readInt32("the DDL result's own database id");
+	reader.readInt32("the DDL result's own session id");
+	const columnTypes = readResultMetaData(reader);
+	const firstColumnType = columnTypes[0];
+	if (columnTypes.length !== 1 || firstColumnType !== SQL_TYPE_VARCHAR) throw new HsqldbBinaryScriptParseError(`the DDL result has ${columnTypes.length} column(s) of type [${columnTypes.join(", ")}] -- a script's own DDL result is always the single VARCHAR "COMMAND" column DatabaseScript.getScript builds`, recordStart);
+	const rowCount = reader.readInt32("the DDL result's own row count");
+	if (rowCount < 0) throw new HsqldbBinaryScriptParseError(`the DDL result declares a negative row count ${rowCount}`, reader.position);
+	const statements = [];
+	for (let i = 0; i < rowCount; i++) {
+		reader.require(1, `DDL statement ${i}`);
+		const value = readHsqldbColumnValue(reader.cursor, SQL_TYPE_VARCHAR);
+		if (value.kind !== "string") throw new HsqldbBinaryScriptParseError(`DDL statement ${i} decoded as a ${value.kind} value rather than a string`, reader.position);
+		statements.push(value.value);
+	}
+	const recordEnd = recordStart + recordLength;
+	if (reader.position > recordEnd) throw new HsqldbBinaryScriptParseError(`the DDL result overran its own declared length (consumed ${reader.position - recordStart} bytes, declared ${recordLength})`, reader.position);
+	reader.position = recordEnd;
+	return statements;
+}
+function readTableSection(reader, tables, options) {
+	if (!reader.hasRecordLength()) return;
+	if (reader.readInt32("a table section's own init record length") === 0) return;
+	const tableName = reader.readString("a table section's own table name");
+	const schemaFlag = reader.readInt32(`table "${tableName}"'s own schema-presence flag`);
+	if (schemaFlag !== TABLE_INIT_WITH_SCHEMA && schemaFlag !== TABLE_INIT_WITHOUT_SCHEMA) throw new HsqldbBinaryScriptParseError(`table "${tableName}"'s init record has schema flag ${schemaFlag}, which is neither ${TABLE_INIT_WITHOUT_SCHEMA} nor ${TABLE_INIT_WITH_SCHEMA}`, reader.position);
+	if (schemaFlag === TABLE_INIT_WITH_SCHEMA) reader.readString(`table "${tableName}"'s own schema name`);
+	const table = tables.get(tableName.toUpperCase());
+	if (table === void 0) throw new HsqldbBinaryScriptParseError(`the data section declares rows for table "${tableName}", which the script's own DDL never declared`, reader.position);
+	const typeCodes = table.columns.map((column) => resolveHsqldbTypeCode(column.type));
+	const rows = [];
+	for (;;) {
+		const rowStart = reader.position;
+		const rowLength = reader.readInt32(`a row length in table "${tableName}"`);
+		if (rowLength === 0) break;
+		if (rowLength < 0) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" declares a negative length ${rowLength}`, rowStart);
+		const rowEnd = rowStart + rowLength;
+		reader.require(rowLength - 4, `a row in table "${tableName}"`);
+		rows.push(typeCodes.map((typeCode) => readHsqldbColumnValue(reader.cursor, typeCode, options)));
+		if (reader.position > rowEnd) throw new HsqldbBinaryScriptParseError(`a row in table "${tableName}" overran its own declared length (consumed ${reader.position - rowStart} bytes, declared ${rowLength})`, reader.position);
+		reader.position = rowEnd;
+	}
+	const declaredRowCount = reader.readInt32(`table "${tableName}"'s own trailing row count`);
+	if (declaredRowCount !== rows.length) throw new HsqldbBinaryScriptParseError(`table "${tableName}" declares ${declaredRowCount} row(s) in its own terminator but the section carried ${rows.length}`, reader.position);
+	return {
+		tableName,
+		rows
+	};
+}
+function parseHsqldbBinaryScript(bytes, options) {
+	const reader = new BinaryScriptCursor(bytes);
+	const scriptText = readDdlStatements(reader).join("\n");
+	const tables = parseHsqldbScript(new TextEncoder().encode(scriptText));
+	const tablesByName = new Map(tables.map((table) => [table.tableName.toUpperCase(), table]));
+	const rowsByTable = /* @__PURE__ */ new Map();
+	for (;;) {
+		const section = readTableSection(reader, tablesByName, options);
+		if (section === void 0) break;
+		rowsByTable.set(section.tableName.toUpperCase(), section.rows);
+	}
+	return {
+		scriptText,
+		tables: tables.map((table) => {
+			const rows = rowsByTable.get(table.tableName.toUpperCase());
+			return rows === void 0 ? table : {
+				...table,
+				rows
+			};
+		})
+	};
+}
+function inflateHsqldbCompressedScript(bytes) {
+	return unzlibSync(bytes);
+}
+//#endregion
+export { HsqldbBinaryScriptParseError, inflateHsqldbCompressedScript, parseHsqldbBinaryScript };

package/dist/hsqldb/cache.cjs

@@ -2,6 +2,7 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_hsqldb_rowformat = require("./rowformat.cjs");
 //#region src/hsqldb/cache.ts
 const SUPPORTED_COMPATIBLE_VERSION_PREFIXES = ["1.7.", "1.8."];
+const DISK_NODE_SIZE_BYTES = 16;
 function parseHsqldbProperties(text) {
 	const props = /* @__PURE__ */ new Map();
 	for (const rawLine of text.split("\n")) {
@@ -32,17 +33,22 @@ function parseHsqldbIndexRoots(scriptText) {
 		const tokensText = match[2] ?? "";
 		const tableName = unquoteIdentifier(rawName).toUpperCase();
 		const tokens = tokensText.trim().length === 0 ? [] : tokensText.trim().split(/\s+/);
-		if (tokens.length !== 2) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}" declares ${Math.max(tokens.length - 1, 0)} index root(s) in its SET TABLE...INDEX line -- only a single-index (primary-key-only) CACHED table is supported`);
+		if (tokens.length < 2) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has ${tokens.length} token(s) -- every such line carries at least one index root position followed by the table's own identity-sequence value`);
+		const indexCount = tokens.length - 1;
 		const rootToken = tokens[0] ?? "";
-		const rootPos = Number(rootToken);
-		if (!Number.isInteger(rootPos)) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has a non-integer root position "${rootToken}"`);
-		roots.set(tableName, rootPos);
+		const rootPosition = Number(rootToken);
+		if (!Number.isInteger(rootPosition)) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`table "${tableName}"'s SET TABLE...INDEX line has a non-integer root position "${rootToken}"`);
+		roots.set(tableName, {
+			rootPosition,
+			indexCount
+		});
 	}
 	return roots;
 }
-function readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, columns) {
+function readHsqldbCachedTableRows(dataBytes, roots, cacheFileScale, columns, options) {
 	const typeCodes = columns.map((column) => require_hsqldb_rowformat.resolveHsqldbTypeCode(column.type));
 	const results = [];
+	const trailingNodeBytes = (roots.indexCount - 1) * DISK_NODE_SIZE_BYTES;
 	function visit(pos) {
 		if (pos <= 0) return;
 		const byteOffset = pos * cacheFileScale;
@@ -55,26 +61,27 @@ function readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, columns)
 		const iLeft = cursor.readInt32();
 		const iRight = cursor.readInt32();
 		cursor.readInt32();
+		cursor.position += trailingNodeBytes;
 		const values = columns.map((_column, index) => {
 			const typeCode = typeCodes[index];
 			if (typeCode === void 0) throw new require_hsqldb_rowformat.HsqldbRowFormatError("internal error: column/type-code alignment failure");
-			return require_hsqldb_rowformat.readHsqldbColumnValue(cursor, typeCode);
+			return require_hsqldb_rowformat.readHsqldbColumnValue(cursor, typeCode, options);
 		});
 		if (cursor.position > rowEnd) throw new require_hsqldb_rowformat.HsqldbRowFormatError(`row at position ${pos} overran its own declared storage size (consumed ${cursor.position - byteOffset} bytes, declared ${storageSize})`);
 		visit(iLeft);
 		results.push(values);
 		visit(iRight);
 	}
-	visit(rootPos);
+	visit(roots.rootPosition);
 	return results;
 }
-function decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText) {
+function decodeHsqldbCachedTables(tables, scriptText, dataBytes, propertiesText, options) {
 	const { cacheFileScale } = parseHsqldbProperties(propertiesText);
 	const roots = parseHsqldbIndexRoots(scriptText);
 	return tables.map((table) => {
-		const rootPos = roots.get(table.tableName.toUpperCase());
-		if (rootPos === void 0) return table;
-		const rows = readHsqldbCachedTableRows(dataBytes, rootPos, cacheFileScale, table.columns);
+		const tableRoots = roots.get(table.tableName.toUpperCase());
+		if (tableRoots === void 0) return table;
+		const rows = readHsqldbCachedTableRows(dataBytes, tableRoots, cacheFileScale, table.columns, options);
 		return {
 			...table,
 			rows