@undefineds.co/xpod 0.3.74 → 0.4.0-rc.139

package/dist/storage/rdf/RdfSparqlBoundary.d.ts

@@ -0,0 +1,37 @@
+export interface UnsupportedSparqlQueryErrorOptions {
+    code?: string;
+    capability?: string;
+    hint?: string;
+    correction?: SparqlCorrection;
+}
+export type SparqlCorrectionAction = 'rewrite_query' | 'constrain_graph_scope' | 'materialize_intermediate' | 'route_external_executor' | 'use_write_api';
+export type SparqlCorrectionTarget = 'embedded_rdf_engine' | 'trusted_client_or_federated_engine' | 'pod_write_api';
+export interface SparqlCorrection {
+    capability: string;
+    primaryAction: SparqlCorrectionAction;
+    availableActions: SparqlCorrectionAction[];
+    target: SparqlCorrectionTarget;
+    message: string;
+}
+export declare class UnsupportedSparqlQueryError extends Error {
+    readonly code: string;
+    readonly capability: string;
+    readonly hint: string;
+    readonly correction: SparqlCorrection;
+    constructor(message: string, options?: UnsupportedSparqlQueryErrorOptions);
+}
+export declare class DisabledSparqlFeatureError extends Error {
+    constructor(message: string);
+}
+export declare class NativeSparqlExecutionError extends Error {
+    readonly code = "rdf.sparql.native_execution_error";
+    constructor(message: string);
+}
+export declare class NativeSparqlTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly code = "rdf.sparql.timeout";
+    constructor(timeoutMs: number, detail?: string);
+}
+export declare function sparqlCorrectionForCapability(capability: string): SparqlCorrection;
+/** Validate only the server-owned graph and SERVICE boundary before native QLever execution. */
+export declare function assertServerOwnedNativeSparqlQuery(query: string, basePath: string): boolean;

package/dist/storage/rdf/RdfSparqlBoundary.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeSparqlTimeoutError = exports.NativeSparqlExecutionError = exports.DisabledSparqlFeatureError = exports.UnsupportedSparqlQueryError = void 0;
+exports.sparqlCorrectionForCapability = sparqlCorrectionForCapability;
+exports.assertServerOwnedNativeSparqlQuery = assertServerOwnedNativeSparqlQuery;
+const sparqljs_1 = require("sparqljs");
+const QLEVER_SERVICE_HOST = 'qlever.cs.uni-freiburg.de';
+const QLEVER_EXTENSION_SERVICE_ENDPOINTS = new Set([
+    `https://${QLEVER_SERVICE_HOST}/pathSearch/`,
+    `https://${QLEVER_SERVICE_HOST}/spatialSearch/`,
+    `https://${QLEVER_SERVICE_HOST}/textSearch/`,
+    `https://${QLEVER_SERVICE_HOST}/external-values/`,
+]);
+const QLEVER_EXTENSION_SERVICE_PREFIXES = [
+    `https://${QLEVER_SERVICE_HOST}/external-values-`,
+    `http://${QLEVER_SERVICE_HOST}/builtin-functions/cached-result-with-name-`,
+    `https://${QLEVER_SERVICE_HOST}/materializedView/`,
+];
+class UnsupportedSparqlQueryError extends Error {
+    constructor(message, options = {}) {
+        const normalizedMessage = normalizeUnsupportedSparqlMessage(message);
+        super(normalizedMessage);
+        this.name = 'UnsupportedSparqlQueryError';
+        this.code = options.code ?? 'rdf.sparql.unsupported_query_shape';
+        this.capability = options.capability ?? inferUnsupportedSparqlCapability(normalizedMessage);
+        this.hint = options.hint ?? unsupportedSparqlHint(this.capability);
+        this.correction = options.correction ?? sparqlCorrectionForCapability(this.capability);
+    }
+}
+exports.UnsupportedSparqlQueryError = UnsupportedSparqlQueryError;
+function normalizeUnsupportedSparqlMessage(message) {
+    const noFallbackMatch = /^No compatibility SPARQL fallback configured for ([^:]+):\s*(.+)$/i.exec(message);
+    if (noFallbackMatch) {
+        return `Embedded SPARQL engine cannot execute ${noFallbackMatch[1]}: ${normalizeEmbeddedUnsupportedReason(noFallbackMatch[2])}`;
+    }
+    return normalizeEmbeddedUnsupportedReason(message);
+}
+function normalizeEmbeddedUnsupportedReason(reason) {
+    let normalized = reason
+        .replace(/\s+fallback to compatibility engine\b/gi, ' is not supported by the embedded RDF engine')
+        .replace(/\bis handled by the compatibility engine\b/gi, 'is not supported by the embedded RDF engine')
+        .replace(/\bcompatibility fallback\b/gi, 'embedded RDF engine');
+    if (/^unsupported shape$/i.test(normalized.trim())) {
+        normalized = 'Query shape is not supported by the embedded RDF engine';
+    }
+    return normalized;
+}
+class DisabledSparqlFeatureError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'DisabledSparqlFeatureError';
+    }
+}
+exports.DisabledSparqlFeatureError = DisabledSparqlFeatureError;
+class NativeSparqlExecutionError extends Error {
+    constructor(message) {
+        super(message.startsWith('Native SPARQL engine failed:') ? message : `Native SPARQL engine failed: ${message}`);
+        this.code = 'rdf.sparql.native_execution_error';
+        this.name = 'NativeSparqlExecutionError';
+    }
+}
+exports.NativeSparqlExecutionError = NativeSparqlExecutionError;
+class NativeSparqlTimeoutError extends Error {
+    constructor(timeoutMs, detail) {
+        super(`Native SPARQL query timed out after ${timeoutMs}ms${detail ? `: ${detail}` : ''}`);
+        this.timeoutMs = timeoutMs;
+        this.code = 'rdf.sparql.timeout';
+        this.name = 'NativeSparqlTimeoutError';
+    }
+}
+exports.NativeSparqlTimeoutError = NativeSparqlTimeoutError;
+function inferUnsupportedSparqlCapability(message) {
+    const normalized = message.toLowerCase();
+    if (normalized.includes('subquer'))
+        return 'sparql.query.subquery';
+    if (normalized.includes('rdf-star'))
+        return 'sparql.query.rdf_star';
+    if (normalized.includes('property path'))
+        return 'sparql.query.property_path';
+    if (normalized.includes('default graph'))
+        return 'sparql.graph.default';
+    if (normalized.includes('graph variable'))
+        return 'sparql.graph.variable';
+    if (normalized.includes('graph outside') || normalized.includes('dataset scope'))
+        return 'sparql.graph.scope';
+    if (normalized.includes('update'))
+        return 'sparql.update.authority';
+    if (normalized.includes('construct'))
+        return 'sparql.query.construct';
+    if (normalized.includes('describe'))
+        return 'sparql.query.describe';
+    if (normalized.includes('wildcard'))
+        return 'sparql.query.wildcard_projection';
+    if (normalized.includes('having'))
+        return 'sparql.query.having';
+    if (normalized.includes('group by') || normalized.includes('grouped'))
+        return 'sparql.query.group';
+    if (normalized.includes('aggregate'))
+        return 'sparql.query.aggregate';
+    if (normalized.includes('values'))
+        return 'sparql.query.values';
+    if (/\bbind\b/.test(normalized))
+        return 'sparql.query.bind';
+    if (normalized.includes('minus'))
+        return 'sparql.query.minus';
+    if (normalized.includes('exists'))
+        return 'sparql.query.exists';
+    if (normalized.includes('optional'))
+        return 'sparql.query.optional';
+    if (normalized.includes('union'))
+        return 'sparql.query.union';
+    if (normalized.includes('filter'))
+        return 'sparql.query.filter';
+    if (normalized.includes('function'))
+        return 'sparql.query.function';
+    return 'sparql.query.shape';
+}
+function unsupportedSparqlHint(capability) {
+    switch (capability) {
+        case 'sparql.query.subquery':
+            return 'Flatten the subquery, materialize its intermediate result, or route it through a trusted external executor.';
+        case 'sparql.query.property_path':
+            return 'Rewrite the property path as explicit predicate patterns, or use a QLever-supported path expression.';
+        case 'sparql.graph.default':
+            return 'Use explicit named GRAPH clauses inside the Pod base path.';
+        case 'sparql.graph.variable':
+            return 'Constrain graph variables to finite named graphs inside the Pod base path.';
+        case 'sparql.graph.scope':
+            return 'Limit GRAPH, FROM, and USING targets to graph documents inside the current Pod base path.';
+        case 'sparql.update.authority':
+            return 'Send the update through the Pod write authority so QLever can prepare an atomic source-file delta.';
+        default:
+            return 'Rewrite the query to a QLever-supported shape, or route it through a trusted external executor.';
+    }
+}
+function sparqlCorrectionForCapability(capability) {
+    if (capability === 'sparql.geosparql') {
+        return {
+            capability,
+            primaryAction: 'route_external_executor',
+            availableActions: ['route_external_executor', 'materialize_intermediate'],
+            target: 'trusted_client_or_federated_engine',
+            message: 'Route GeoSPARQL to a trusted external executor until Xpod has a concrete native product workload.',
+        };
+    }
+    if (capability === 'sparql.federation.service') {
+        return {
+            capability,
+            primaryAction: 'route_external_executor',
+            availableActions: ['route_external_executor'],
+            target: 'trusted_client_or_federated_engine',
+            message: 'Execute SERVICE federation from a trusted client-side or federated query layer.',
+        };
+    }
+    if (capability === 'sparql.update.authority' || capability === 'sparql.update.embedded_delta') {
+        return {
+            capability,
+            primaryAction: 'use_write_api',
+            availableActions: ['use_write_api', 'rewrite_query'],
+            target: 'pod_write_api',
+            message: 'Apply the update through the Pod write authority and its QLever prepared-delta contract.',
+        };
+    }
+    if (capability === 'sparql.query.subquery' || capability === 'sparql.query.rdf_star') {
+        return {
+            capability,
+            primaryAction: 'materialize_intermediate',
+            availableActions: ['materialize_intermediate', 'rewrite_query', 'route_external_executor'],
+            target: 'embedded_rdf_engine',
+            message: 'Materialize the unsupported intermediate result before retrying, or route it through a trusted external executor.',
+        };
+    }
+    if (capability.startsWith('sparql.graph.')) {
+        return {
+            capability,
+            primaryAction: 'constrain_graph_scope',
+            availableActions: ['constrain_graph_scope', 'rewrite_query'],
+            target: 'embedded_rdf_engine',
+            message: 'Constrain graph scope to named graph documents inside the current Pod base path.',
+        };
+    }
+    return {
+        capability,
+        primaryAction: 'rewrite_query',
+        availableActions: ['rewrite_query', 'route_external_executor'],
+        target: 'embedded_rdf_engine',
+        message: 'Rewrite the query to a QLever-supported shape, or route it through a trusted external executor.',
+    };
+}
+/** Validate only the server-owned graph and SERVICE boundary before native QLever execution. */
+function assertServerOwnedNativeSparqlQuery(query, basePath) {
+    const parsed = new sparqljs_1.Parser({ baseIRI: basePath }).parse(query);
+    const usesQleverExtensionService = assertNoExternalService(parsed);
+    if (parsed.type !== 'update') {
+        assertNativeDatasetScope(queryFromClause(parsed), basePath);
+    }
+    return usesQleverExtensionService;
+}
+function isQleverExtensionServiceEndpoint(value) {
+    if (value === null || typeof value !== 'object')
+        return false;
+    const endpoint = value;
+    if (endpoint.termType !== 'NamedNode' || typeof endpoint.value !== 'string')
+        return false;
+    return QLEVER_EXTENSION_SERVICE_ENDPOINTS.has(endpoint.value)
+        || QLEVER_EXTENSION_SERVICE_PREFIXES.some((prefix) => endpoint.value.startsWith(prefix));
+}
+function assertNoExternalService(value) {
+    if (Array.isArray(value)) {
+        let usesQleverExtensionService = false;
+        for (const item of value) {
+            if (assertNoExternalService(item))
+                usesQleverExtensionService = true;
+        }
+        return usesQleverExtensionService;
+    }
+    if (value === null || typeof value !== 'object')
+        return false;
+    const record = value;
+    let usesQleverExtensionService = false;
+    if (record.type === 'service') {
+        if (!isQleverExtensionServiceEndpoint(record.name)) {
+            throw new DisabledSparqlFeatureError('SPARQL SERVICE federation is disabled for server-owned Pod queries');
+        }
+        usesQleverExtensionService = true;
+    }
+    for (const child of Object.values(record)) {
+        if (assertNoExternalService(child))
+            usesQleverExtensionService = true;
+    }
+    return usesQleverExtensionService;
+}
+function assertNativeDatasetScope(datasets, basePath) {
+    for (const graph of [...datasets.default, ...datasets.named]) {
+        if (!graph.value.startsWith(basePath)) {
+            throw new DisabledSparqlFeatureError(`SPARQL dataset graph is outside the server-owned Pod scope: ${graph.value}`);
+        }
+    }
+}
+function queryFromClause(query) {
+    const from = 'from' in query ? query.from : undefined;
+    return {
+        default: from?.default ?? [],
+        named: from?.named ?? [],
+    };
+}
+//# sourceMappingURL=RdfSparqlBoundary.js.map

package/dist/storage/rdf/RdfSparqlSerialization.d.ts

@@ -0,0 +1,3 @@
+export declare function validateSparqlIri(value: string): string;
+export declare function serializeSparqlIri(value: string): string;
+export declare function serializeSparqlString(value: string): string;

package/dist/storage/rdf/RdfSparqlSerialization.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSparqlIri = validateSparqlIri;
+exports.serializeSparqlIri = serializeSparqlIri;
+exports.serializeSparqlString = serializeSparqlString;
+const INVALID_IRIREF_CHARACTER = /[<>"{}|^`\\\u0000-\u0020]/u;
+function validateSparqlIri(value) {
+    if (INVALID_IRIREF_CHARACTER.test(value)) {
+        throw new Error(`Unsafe IRI for SPARQL query: ${value}`);
+    }
+    return value;
+}
+function serializeSparqlIri(value) {
+    return `<${validateSparqlIri(value)}>`;
+}
+function serializeSparqlString(value) {
+    return JSON.stringify(value);
+}
+//# sourceMappingURL=RdfSparqlSerialization.js.map

package/dist/storage/rdf/RdfSqliteConnection.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteDatabase, SqliteRuntime } from '../SqliteRuntime';
+/**
+ * Open the SQLite file shared by Local facts, FTS, VEC, and the QLever reader.
+ * WAL lets the long-lived native reader coexist with short authority writes;
+ * busy_timeout bounds transient writer contention instead of failing at once.
+ */
+export declare function openRdfSqliteDatabase(sqliteRuntime: SqliteRuntime, path: string): SqliteDatabase;

package/dist/storage/rdf/RdfSqliteConnection.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openRdfSqliteDatabase = openRdfSqliteDatabase;
+/**
+ * Open the SQLite file shared by Local facts, FTS, VEC, and the QLever reader.
+ * WAL lets the long-lived native reader coexist with short authority writes;
+ * busy_timeout bounds transient writer contention instead of failing at once.
+ */
+function openRdfSqliteDatabase(sqliteRuntime, path) {
+    const db = sqliteRuntime.openDatabase(path);
+    if (!isInMemorySqlitePath(path)) {
+        db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA busy_timeout = 5000;
+      PRAGMA synchronous = NORMAL;
+    `);
+    }
+    return db;
+}
+function isInMemorySqlitePath(path) {
+    return path === ':memory:' || path.startsWith(':memory:');
+}
+//# sourceMappingURL=RdfSqliteConnection.js.map

package/dist/storage/rdf/RdfTermDictionary.d.ts

@@ -10,7 +10,6 @@ export declare class RdfTermDictionary {
     private readonly termCache;
     private readonly idCache;
     constructor(db: SqliteDatabase);
-    initialize(): void;
     getOrCreate(term: Term): number;
     find(term: Term): number | undefined;
     termForId(id: number): Term;
@@ -25,15 +24,8 @@ export declare class RdfTermDictionary {
     private toIdentity;
     private identity;
     private numericValueForLiteral;
-    private ensureSafeTermTableSchema;
-    private createSafeTermTable;
-    private dropUnsafeRawTextIndexes;
-    private ensureValueHeadColumn;
-    private ensureNumericValueColumn;
-    private backfillNumericValues;
     private identityCacheKey;
     private rowMatchesIdentity;
-    private termTableColumns;
     private rowToTerm;
 }
 export declare function rdfTermValueHead(value: string): string;

package/dist/storage/rdf/RdfTermDictionary.js

@@ -15,20 +15,6 @@ class RdfTermDictionary {
         this.termCache = new Map();
         this.idCache = new Map();
     }
-    initialize() {
-        this.ensureSafeTermTableSchema();
-        this.dropUnsafeRawTextIndexes();
-        this.ensureValueHeadColumn();
-        this.ensureNumericValueColumn();
-        this.db.exec(`
-      CREATE UNIQUE INDEX IF NOT EXISTS rdf_terms_identity_hash ON rdf_terms (hash);
-      CREATE INDEX IF NOT EXISTS rdf_terms_kind_value_head ON rdf_terms (kind, value_head);
-      CREATE INDEX IF NOT EXISTS rdf_terms_kind_datatype ON rdf_terms (kind, datatype_id);
-      CREATE INDEX IF NOT EXISTS rdf_terms_kind_lang ON rdf_terms (kind, lang);
-      CREATE INDEX IF NOT EXISTS rdf_terms_kind_numeric_value ON rdf_terms (kind, numeric_value);
-    `);
-        this.backfillNumericValues();
-    }
     getOrCreate(term) {
         const identity = this.toIdentity(term);
         const cacheKey = this.identityCacheKey(identity);
@@ -368,125 +354,6 @@ class RdfTermDictionary {
         const numeric = (0, RdfTermSemantics_1.rdfNumericValue)(value);
         return Number.isFinite(numeric) ? numeric : null;
     }
-    ensureSafeTermTableSchema() {
-        const table = this.db
-            .prepare("SELECT sql FROM sqlite_schema WHERE type = 'table' AND name = 'rdf_terms'")
-            .get();
-        if (!table) {
-            this.createSafeTermTable('rdf_terms');
-            return;
-        }
-        const columns = this.termTableColumns();
-        const hasRawUniqueConstraint = table.sql?.includes('UNIQUE (kind, value, datatype_id, lang)') ?? false;
-        if (!hasRawUniqueConstraint && columns.has('value_head') && columns.has('numeric_value')) {
-            return;
-        }
-        const foreignKeys = this.db.prepare('PRAGMA foreign_keys').get()?.foreign_keys ?? 0;
-        this.db.exec('PRAGMA foreign_keys = OFF;');
-        try {
-            this.db.transaction(() => {
-                this.db.exec('DROP TABLE IF EXISTS rdf_terms_next;');
-                this.createSafeTermTable('rdf_terms_next');
-                this.db.exec(`
-          INSERT INTO rdf_terms_next (
-            id,
-            kind,
-            value,
-            value_head,
-            datatype_id,
-            lang,
-            hash,
-            normalized_text,
-            numeric_value,
-            created_at
-          )
-          SELECT
-            id,
-            kind,
-            value,
-            substr(value, 1, ${exports.RDF_TERM_VALUE_HEAD_LENGTH}),
-            datatype_id,
-            lang,
-            hash,
-            normalized_text,
-            ${columns.has('numeric_value') ? 'numeric_value' : 'NULL'},
-            created_at
-          FROM rdf_terms;
-        `);
-                this.db.exec(`
-          DROP TABLE rdf_terms;
-          ALTER TABLE rdf_terms_next RENAME TO rdf_terms;
-        `);
-            })();
-        }
-        finally {
-            if (foreignKeys) {
-                this.db.exec('PRAGMA foreign_keys = ON;');
-            }
-        }
-    }
-    createSafeTermTable(name) {
-        this.db.exec(`
-      CREATE TABLE IF NOT EXISTS ${name} (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        kind TEXT NOT NULL,
-        value TEXT NOT NULL,
-        value_head TEXT NOT NULL,
-        datatype_id INTEGER,
-        lang TEXT,
-        hash TEXT NOT NULL,
-        normalized_text TEXT,
-        numeric_value REAL,
-        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
-      );
-    `);
-    }
-    dropUnsafeRawTextIndexes() {
-        this.db.exec(`
-      DROP INDEX IF EXISTS rdf_terms_hash;
-      DROP INDEX IF EXISTS rdf_terms_kind_value;
-      DROP INDEX IF EXISTS rdf_terms_normalized_text;
-    `);
-    }
-    ensureValueHeadColumn() {
-        const columns = this.termTableColumns();
-        if (!columns.has('value_head')) {
-            this.db.exec('ALTER TABLE rdf_terms ADD COLUMN value_head TEXT;');
-        }
-        this.db.exec(`
-      UPDATE rdf_terms
-      SET value_head = substr(value, 1, ${exports.RDF_TERM_VALUE_HEAD_LENGTH})
-      WHERE value_head IS NULL;
-    `);
-    }
-    ensureNumericValueColumn() {
-        const columns = this.termTableColumns();
-        if (columns.has('numeric_value')) {
-            return;
-        }
-        this.db.exec('ALTER TABLE rdf_terms ADD COLUMN numeric_value REAL;');
-    }
-    backfillNumericValues() {
-        const rows = this.db.prepare(`
-      SELECT literal.*
-      FROM rdf_terms literal
-      JOIN rdf_terms datatype ON datatype.id = literal.datatype_id
-      WHERE literal.kind = 'literal'
-        AND literal.numeric_value IS NULL
-        AND datatype.kind = 'iri'
-    `).all();
-        const update = this.db.prepare('UPDATE rdf_terms SET numeric_value = ? WHERE id = ?');
-        for (const row of rows) {
-            const datatype = this.termForId(row.datatype_id);
-            if (datatype.termType !== 'NamedNode') {
-                continue;
-            }
-            const numericValue = this.numericValueForLiteral(row.value, datatype.value);
-            if (numericValue !== null) {
-                update.run(numericValue, row.id);
-            }
-        }
-    }
     identityCacheKey(identity) {
         return [
             identity.kind,
@@ -501,9 +368,6 @@ class RdfTermDictionary {
             && row.datatype_id === identity.datatypeId
             && row.lang === identity.lang;
     }
-    termTableColumns() {
-        return new Set(this.db.prepare('PRAGMA table_info(rdf_terms)').all().map((column) => column.name));
-    }
     rowToTerm(row) {
         switch (row.kind) {
             case 'iri':

package/dist/storage/rdf/RdfTermDictionary.jsonld

@@ -31,10 +31,6 @@
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_constructor",
           "memberFieldName": "constructor"
         },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_initialize",
-          "memberFieldName": "initialize"
-        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_getOrCreate",
           "memberFieldName": "getOrCreate"
@@ -91,30 +87,6 @@
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_numericValueForLiteral",
           "memberFieldName": "numericValueForLiteral"
         },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_ensureSafeTermTableSchema",
-          "memberFieldName": "ensureSafeTermTableSchema"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_createSafeTermTable",
-          "memberFieldName": "createSafeTermTable"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_dropUnsafeRawTextIndexes",
-          "memberFieldName": "dropUnsafeRawTextIndexes"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_ensureValueHeadColumn",
-          "memberFieldName": "ensureValueHeadColumn"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_ensureNumericValueColumn",
-          "memberFieldName": "ensureNumericValueColumn"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_backfillNumericValues",
-          "memberFieldName": "backfillNumericValues"
-        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_identityCacheKey",
           "memberFieldName": "identityCacheKey"
@@ -123,10 +95,6 @@
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_rowMatchesIdentity",
           "memberFieldName": "rowMatchesIdentity"
         },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_termTableColumns",
-          "memberFieldName": "termTableColumns"
-        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfTermDictionary.jsonld#RdfTermDictionary__member_rowToTerm",
           "memberFieldName": "rowToTerm"

package/dist/storage/rdf/RdfTermSemantics.d.ts

@@ -4,3 +4,9 @@ export declare function isRdfNumericDatatype(datatype: string): boolean;
 export declare function isFiniteNumericLexical(value: string | number): boolean;
 export declare function rdfNumericValue(value: string | number): number;
 export declare function isRdfNumericTerm(term: Term): boolean;
+/**
+ * Completes the numeric ORDER BY relation where SPARQL value comparison is
+ * unordered: Xpod and QLever place NaN after every other numeric value.
+ * All non-NaN comparisons stay owned by the query evaluator.
+ */
+export declare function compareRdfNumericNaNOrder(left: Term | undefined, right: Term | undefined): -1 | 0 | 1 | undefined;

package/dist/storage/rdf/RdfTermSemantics.js

@@ -5,6 +5,7 @@ exports.isRdfNumericDatatype = isRdfNumericDatatype;
 exports.isFiniteNumericLexical = isFiniteNumericLexical;
 exports.rdfNumericValue = rdfNumericValue;
 exports.isRdfNumericTerm = isRdfNumericTerm;
+exports.compareRdfNumericNaNOrder = compareRdfNumericNaNOrder;
 exports.RDF_NUMERIC_DATATYPES = [
     'http://www.w3.org/2001/XMLSchema#integer',
     'http://www.w3.org/2001/XMLSchema#decimal',
@@ -37,4 +38,32 @@ function isRdfNumericTerm(term) {
         && isRdfNumericDatatype(term.datatype.value)
         && isFiniteNumericLexical(term.value);
 }
+/**
+ * Completes the numeric ORDER BY relation where SPARQL value comparison is
+ * unordered: Xpod and QLever place NaN after every other numeric value.
+ * All non-NaN comparisons stay owned by the query evaluator.
+ */
+function compareRdfNumericNaNOrder(left, right) {
+    if (!isRdfNumericLiteral(left) || !isRdfNumericLiteral(right)) {
+        return undefined;
+    }
+    const leftNaN = isRdfNaNTerm(left);
+    const rightNaN = isRdfNaNTerm(right);
+    if (!leftNaN && !rightNaN) {
+        return undefined;
+    }
+    if (leftNaN === rightNaN) {
+        return 0;
+    }
+    return leftNaN ? 1 : -1;
+}
+function isRdfNumericLiteral(term) {
+    return term?.termType === 'Literal' && isRdfNumericDatatype(term.datatype.value);
+}
+function isRdfNaNTerm(term) {
+    const datatype = term.datatype.value;
+    return term.value === 'NaN'
+        && (datatype === 'http://www.w3.org/2001/XMLSchema#double'
+            || datatype === 'http://www.w3.org/2001/XMLSchema#float');
+}
 //# sourceMappingURL=RdfTermSemantics.js.map

package/dist/storage/rdf/RdfTextIndex.d.ts

@@ -1,6 +1,6 @@
-import type { RdfTextChunkInput, RdfTextChunkRow, RdfTextIndexOptions, RdfTextIndexSyncLike, RdfTextRebuildStatus, RdfTextRebuildStatusInput, RdfTextSearchOrder, RdfTextIndexStats, RdfSearchCardinalityEstimate, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceMetadata, RdfTextSourceInput, RdfTextTermDocumentFrequency, RdfTextRetrievalKind } from './types';
+import type { RdfTextChunkInput, RdfTextChunkRow, RdfTextIndexOptions, RdfTextIndexSyncLike, RdfTextRebuildStatus, RdfTextRebuildStatusInput, RdfTextSearchOrder, RdfTextIndexStats, RdfSearchCardinalityEstimate, RdfTextSearchOptions, RdfTextSearchResult, RdfTextSourceListOptions, RdfTextSourceMetadata, RdfTextSourceInput, RdfTextTermDocumentFrequency, RdfTextRetrievalKind } from './types';
 export declare const RDF_TEXT_TERM_MAX_INDEX_LENGTH = 256;
-export declare const RDF_TEXT_SCHEMA_VERSION = 2;
+export declare const RDF_TEXT_SCHEMA_VERSION = 3;
 export declare class RdfTextIndex implements RdfTextIndexSyncLike {
     private readonly options;
     private readonly sqliteRuntime;
@@ -11,20 +11,19 @@ export declare class RdfTextIndex implements RdfTextIndexSyncLike {
     clear(): void;
     schemaVersion(): number;
     sourceMetadata(source: string): RdfTextSourceMetadata | undefined;
+    listSources(options?: RdfTextSourceListOptions): RdfTextSourceMetadata[];
     recordRebuildStatus(input: RdfTextRebuildStatusInput): void;
     rebuildStatus(source: string): RdfTextRebuildStatus | undefined;
     indexText(source: RdfTextSourceInput, text: string, chunks?: RdfTextChunkInput[]): void;
     moveSource(oldSource: string, next: RdfTextSourceInput): number;
     deleteSource(source: string): number;
+    listSourceChunks(sourceKey: string): RdfTextSearchResult[];
     search(options: RdfTextSearchOptions): RdfTextSearchResult[];
     estimateSearchCardinality(options: RdfTextSearchOptions): RdfSearchCardinalityEstimate;
     stats(): RdfTextIndexStats;
     termDocumentFrequency(limit?: number): RdfTextTermDocumentFrequency[];
     private initializeSchema;
-    private ensureSourceKeyColumn;
-    private ensureChunkRetrievalColumns;
-    private ensureEntityProvenanceColumns;
-    private backfillTermPostings;
+    private validateSchema;
     private upsertSource;
     private chunkText;
     private estimateDatabaseBytes;