@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/rdf/RdfQuadIndex.js

@@ -1,19 +1,66 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RdfQuadIndex = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
+exports.assertRdfFactsSchemaCompatible = assertRdfFactsSchemaCompatible;
 const n3_1 = require("n3");
 const SqliteRuntime_1 = require("../SqliteRuntime");
 const types_1 = require("../quint/types");
 const RdfTermDictionary_1 = require("./RdfTermDictionary");
-const Rdf3xSchema_1 = require("./Rdf3xSchema");
 const RdfJoinShape_1 = require("./RdfJoinShape");
+const RdfSqliteConnection_1 = require("./RdfSqliteConnection");
 const RdfTermSemantics_1 = require("./RdfTermSemantics");
 const XSD_INTEGER = 'http://www.w3.org/2001/XMLSchema#integer';
 const XSD_DECIMAL = 'http://www.w3.org/2001/XMLSchema#decimal';
 const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
 const RDF_QUAD_INDEX_SCHEMA_VERSION = 1;
+const RDF_QUAD_REQUIRED_COLUMNS = {
+    rdf_terms: [
+        'id',
+        'kind',
+        'value',
+        'value_head',
+        'datatype_id',
+        'lang',
+        'hash',
+        'normalized_text',
+        'numeric_value',
+        'created_at',
+    ],
+    rdf_sources: [
+        'id',
+        'source',
+        'workspace',
+        'local_path',
+        'content_type',
+        'last_indexed_at',
+        'source_version',
+    ],
+    rdf_quads: [
+        'graph_id',
+        'subject_id',
+        'predicate_id',
+        'object_id',
+        'source_file_id',
+        'source_line_no',
+    ],
+    rdf_index_metadata: ['key', 'value'],
+};
+const RDF_QUAD_REQUIRED_INDEXES = {
+    rdf_terms_identity_hash: { table: 'rdf_terms', columns: ['hash'], unique: true },
+    rdf_terms_kind_value_head: { table: 'rdf_terms', columns: ['kind', 'value_head'], unique: false },
+    rdf_terms_kind_datatype: { table: 'rdf_terms', columns: ['kind', 'datatype_id'], unique: false },
+    rdf_terms_kind_lang: { table: 'rdf_terms', columns: ['kind', 'lang'], unique: false },
+    rdf_terms_kind_numeric_value: { table: 'rdf_terms', columns: ['kind', 'numeric_value'], unique: false },
+    rdf_quads_spog: { table: 'rdf_quads', columns: ['subject_id', 'predicate_id', 'object_id', 'graph_id'], unique: false },
+    rdf_quads_sopg: { table: 'rdf_quads', columns: ['subject_id', 'object_id', 'predicate_id', 'graph_id'], unique: false },
+    rdf_quads_psog: { table: 'rdf_quads', columns: ['predicate_id', 'subject_id', 'object_id', 'graph_id'], unique: false },
+    rdf_quads_posg: { table: 'rdf_quads', columns: ['predicate_id', 'object_id', 'subject_id', 'graph_id'], unique: false },
+    rdf_quads_ospg: { table: 'rdf_quads', columns: ['object_id', 'subject_id', 'predicate_id', 'graph_id'], unique: false },
+    rdf_quads_opsg: { table: 'rdf_quads', columns: ['object_id', 'predicate_id', 'subject_id', 'graph_id'], unique: false },
+    rdf_quads_gspo: { table: 'rdf_quads', columns: ['graph_id', 'subject_id', 'predicate_id', 'object_id'], unique: false },
+    rdf_quads_gpos: { table: 'rdf_quads', columns: ['graph_id', 'predicate_id', 'object_id', 'subject_id'], unique: false },
+    rdf_quads_source: { table: 'rdf_quads', columns: ['source_file_id'], unique: false },
+};
 const TERM_COLUMN = {
     graph: 'graph_id',
     subject: 'subject_id',
@@ -31,6 +78,108 @@ function emptyTermRewriteResult() {
         affectedQuads: 0,
     };
 }
+function assertRdfFactsSchemaCompatible(db) {
+    if (!sqliteTableExists(db, 'rdf_index_metadata')) {
+        throw new Error('Unsupported RDF facts schema: missing table rdf_index_metadata');
+    }
+    const schemaVersion = rdfFactsMetadataValue(db, 'schema_version');
+    if (schemaVersion === undefined) {
+        throw new Error('Unsupported RDF facts schema: missing schema_version metadata');
+    }
+    if (schemaVersion !== String(RDF_QUAD_INDEX_SCHEMA_VERSION)) {
+        throw new Error(`Unsupported RDF facts schema version: ${schemaVersion}`);
+    }
+    const dataVersion = rdfFactsMetadataValue(db, 'data_version');
+    if (dataVersion === undefined) {
+        throw new Error('Unsupported RDF facts schema: missing data_version metadata');
+    }
+    if (!/^(0|[1-9]\d*)$/.test(dataVersion)) {
+        throw new Error(`Unsupported RDF facts data version: ${dataVersion}`);
+    }
+    for (const [table, columns] of Object.entries(RDF_QUAD_REQUIRED_COLUMNS)) {
+        assertRdfFactsTableColumns(db, table, columns);
+    }
+    for (const [index, definition] of Object.entries(RDF_QUAD_REQUIRED_INDEXES)) {
+        assertRdfFactsIndex(db, index, definition);
+    }
+    const legacyRows = db.prepare(`
+    SELECT name
+    FROM sqlite_schema
+    WHERE name IN ('rdf_terms_hash', 'rdf_terms_kind_value', 'rdf_terms_normalized_text')
+  `).all();
+    if (legacyRows.length > 0) {
+        throw new Error(`Unsupported RDF facts schema: legacy indexes ${legacyRows.map((row) => row.name).join(', ')}`);
+    }
+    const uniqueTermIndexes = db
+        .prepare('PRAGMA index_list(rdf_terms)')
+        .all()
+        .filter((row) => row.unique === 1);
+    for (const index of uniqueTermIndexes) {
+        const columns = sqliteIndexColumns(db, index.name);
+        if (sameStringList(columns, ['kind', 'value', 'datatype_id', 'lang'])) {
+            throw new Error(`Unsupported RDF facts schema: raw-value unique index ${index.name}`);
+        }
+    }
+}
+function sqliteTableExists(db, table) {
+    return Boolean(db
+        .prepare("SELECT name FROM sqlite_schema WHERE type = 'table' AND name = ?")
+        .get(table));
+}
+function rdfFactsMetadataValue(db, key) {
+    return db
+        .prepare('SELECT value FROM rdf_index_metadata WHERE key = ?')
+        .get(key)?.value;
+}
+function assertRdfFactsTableColumns(db, table, requiredColumns) {
+    const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (rows.length === 0) {
+        throw new Error(`Unsupported RDF facts schema: missing table ${table}`);
+    }
+    const columns = rows.map((row) => row.name);
+    const missing = requiredColumns.filter((column) => !columns.includes(column));
+    if (missing.length > 0) {
+        throw new Error(`Unsupported RDF facts schema: ${table} missing columns ${missing.join(', ')}`);
+    }
+    const unexpected = columns.filter((column) => !requiredColumns.includes(column));
+    if (unexpected.length > 0) {
+        throw new Error(`Unsupported RDF facts schema: ${table} has unexpected columns ${unexpected.join(', ')}`);
+    }
+    if (!sameStringList(columns, requiredColumns)) {
+        throw new Error(`Unsupported RDF facts schema: ${table} column order is not canonical`);
+    }
+}
+function assertRdfFactsIndex(db, index, definition) {
+    const row = db
+        .prepare("SELECT name, tbl_name FROM sqlite_schema WHERE type = 'index' AND name = ?")
+        .get(index);
+    if (!row) {
+        throw new Error(`Unsupported RDF facts schema: missing index ${index}`);
+    }
+    if (row.tbl_name !== definition.table) {
+        throw new Error(`Unsupported RDF facts schema: index ${index} belongs to ${row.tbl_name}`);
+    }
+    const indexListRow = db
+        .prepare(`PRAGMA index_list(${definition.table})`)
+        .all()
+        .find((candidate) => candidate.name === index);
+    if (!indexListRow || (indexListRow.unique === 1) !== definition.unique) {
+        throw new Error(`Unsupported RDF facts schema: index ${index} uniqueness is not canonical`);
+    }
+    const columns = sqliteIndexColumns(db, index);
+    if (!sameStringList(columns, definition.columns)) {
+        throw new Error(`Unsupported RDF facts schema: index ${index} columns are not canonical`);
+    }
+}
+function sqliteIndexColumns(db, index) {
+    return db
+        .prepare('SELECT name FROM pragma_index_info(?) ORDER BY seqno')
+        .all(index)
+        .map((row) => row.name);
+}
+function sameStringList(actual, expected) {
+    return actual.length === expected.length && actual.every((value, index) => value === expected[index]);
+}
 class RdfQuadIndex {
     constructor(options) {
         this.options = options;
@@ -43,17 +192,16 @@ class RdfQuadIndex {
         if (this.db) {
             return;
         }
-        if (this.options.path !== ':memory:') {
-            const dir = (0, node_path_1.dirname)(this.options.path);
-            if (!(0, node_fs_1.existsSync)(dir)) {
-                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
-            }
+        this.db = (0, RdfSqliteConnection_1.openRdfSqliteDatabase)(this.sqliteRuntime, this.options.path);
+        try {
+            this.prepareFactsSchema();
+            this.dictionary = new RdfTermDictionary_1.RdfTermDictionary(this.db);
+        }
+        catch (error) {
+            this.db.close();
+            this.db = null;
+            throw error;
         }
-        this.db = this.sqliteRuntime.openDatabase(this.options.path);
-        this.prepareSchemaVersion();
-        this.dictionary = new RdfTermDictionary_1.RdfTermDictionary(this.db);
-        this.dictionary.initialize();
-        this.initializeSchema();
     }
     close() {
         this.db?.close();
@@ -241,12 +389,6 @@ class RdfQuadIndex {
             .get();
         return Number(row?.value ?? 0) || 0;
     }
-    migrationState(name) {
-        return this.requireDb().prepare('SELECT value FROM rdf_index_metadata WHERE key = ?').get(`migration:${name}`)?.value;
-    }
-    setMigrationState(name, state) {
-        this.setMetadataValue(`migration:${name}`, state);
-    }
     scan(pattern, options) {
         if (isRdfPatternQueryInput(pattern)) {
             return this.scanInternal(pattern.pattern, options ?? pattern.options);
@@ -518,6 +660,7 @@ class RdfQuadIndex {
                     equalityColumns.add(TERM_COLUMN[key]);
                 }
             }
+            this.addSourceScopeConditions(entry.pattern.sourceScope, alias, alias, joins, conditions, params, queryPlan);
             indexChoices.push(this.chooseIndex(equalityColumns));
         }
         const projectVariables = options?.project ?? [...variableColumns.keys()];
@@ -1055,9 +1198,37 @@ class RdfQuadIndex {
             return 4096;
         }
     }
-    initializeSchema() {
-        this.requireDb().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_sources (
+    prepareFactsSchema() {
+        if (this.hasExistingFactsSchema()) {
+            assertRdfFactsSchemaCompatible(this.requireDb());
+            return;
+        }
+        this.createFreshFactsSchema();
+    }
+    createFreshFactsSchema() {
+        const db = this.requireDb();
+        db.transaction(() => {
+            db.exec(`
+      CREATE TABLE rdf_terms (
+        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'))
+      );
+
+      CREATE UNIQUE INDEX rdf_terms_identity_hash ON rdf_terms (hash);
+      CREATE INDEX rdf_terms_kind_value_head ON rdf_terms (kind, value_head);
+      CREATE INDEX rdf_terms_kind_datatype ON rdf_terms (kind, datatype_id);
+      CREATE INDEX rdf_terms_kind_lang ON rdf_terms (kind, lang);
+      CREATE INDEX rdf_terms_kind_numeric_value ON rdf_terms (kind, numeric_value);
+
+      CREATE TABLE rdf_sources (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         source TEXT NOT NULL UNIQUE,
         workspace TEXT NOT NULL,
@@ -1067,7 +1238,7 @@ class RdfQuadIndex {
         source_version TEXT
       );
 
-      CREATE TABLE IF NOT EXISTS rdf_quads (
+      CREATE TABLE rdf_quads (
         graph_id INTEGER NOT NULL,
         subject_id INTEGER NOT NULL,
         predicate_id INTEGER NOT NULL,
@@ -1082,94 +1253,49 @@ class RdfQuadIndex {
         FOREIGN KEY (source_file_id) REFERENCES rdf_sources(id)
       );
 
-      CREATE INDEX IF NOT EXISTS rdf_quads_spog ON rdf_quads(subject_id, predicate_id, object_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_sopg ON rdf_quads(subject_id, object_id, predicate_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_psog ON rdf_quads(predicate_id, subject_id, object_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_posg ON rdf_quads(predicate_id, object_id, subject_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_ospg ON rdf_quads(object_id, subject_id, predicate_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_opsg ON rdf_quads(object_id, predicate_id, subject_id, graph_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_gspo ON rdf_quads(graph_id, subject_id, predicate_id, object_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_gpos ON rdf_quads(graph_id, predicate_id, object_id, subject_id);
-      CREATE INDEX IF NOT EXISTS rdf_quads_source ON rdf_quads(source_file_id);
+      CREATE INDEX rdf_quads_spog ON rdf_quads(subject_id, predicate_id, object_id, graph_id);
+      CREATE INDEX rdf_quads_sopg ON rdf_quads(subject_id, object_id, predicate_id, graph_id);
+      CREATE INDEX rdf_quads_psog ON rdf_quads(predicate_id, subject_id, object_id, graph_id);
+      CREATE INDEX rdf_quads_posg ON rdf_quads(predicate_id, object_id, subject_id, graph_id);
+      CREATE INDEX rdf_quads_ospg ON rdf_quads(object_id, subject_id, predicate_id, graph_id);
+      CREATE INDEX rdf_quads_opsg ON rdf_quads(object_id, predicate_id, subject_id, graph_id);
+      CREATE INDEX rdf_quads_gspo ON rdf_quads(graph_id, subject_id, predicate_id, object_id);
+      CREATE INDEX rdf_quads_gpos ON rdf_quads(graph_id, predicate_id, object_id, subject_id);
+      CREATE INDEX rdf_quads_source ON rdf_quads(source_file_id);
 
-      CREATE TABLE IF NOT EXISTS rdf_index_metadata (
+      CREATE TABLE rdf_index_metadata (
         key TEXT PRIMARY KEY,
         value TEXT NOT NULL
       );
-    `);
-        this.requireDb().prepare(`
-      INSERT OR IGNORE INTO rdf_index_metadata (key, value)
-      SELECT 'data_version', '1'
-      WHERE EXISTS (SELECT 1 FROM rdf_quads LIMIT 1)
-    `).run();
-    }
-    prepareSchemaVersion() {
-        this.ensureMetadataTable();
-        const db = this.requireDb();
-        const row = db
-            .prepare("SELECT value FROM rdf_index_metadata WHERE key = 'schema_version'")
-            .get();
-        if (row && row.value !== String(RDF_QUAD_INDEX_SCHEMA_VERSION)) {
-            this.dropIndexSchema();
-            this.ensureMetadataTable();
-        }
-        this.setMetadataValue('schema_version', String(RDF_QUAD_INDEX_SCHEMA_VERSION));
-    }
-    ensureMetadataTable() {
-        this.requireDb().exec(`
-      CREATE TABLE IF NOT EXISTS rdf_index_metadata (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      );
-    `);
+
+      INSERT INTO rdf_index_metadata (key, value) VALUES ('data_version', '0');
+      INSERT INTO rdf_index_metadata (key, value) VALUES ('schema_version', '${RDF_QUAD_INDEX_SCHEMA_VERSION}');
+      `);
+        })();
     }
-    dropIndexSchema() {
+    hasExistingFactsSchema() {
         const db = this.requireDb();
-        const foreignKeys = db.prepare('PRAGMA foreign_keys').get()?.foreign_keys ?? 0;
-        db.exec('PRAGMA foreign_keys = OFF;');
-        try {
-            db.exec(`
-        DROP INDEX IF EXISTS rdf_quads_spog;
-        DROP INDEX IF EXISTS rdf_quads_sopg;
-        DROP INDEX IF EXISTS rdf_quads_psog;
-        DROP INDEX IF EXISTS rdf_quads_posg;
-        DROP INDEX IF EXISTS rdf_quads_ospg;
-        DROP INDEX IF EXISTS rdf_quads_opsg;
-        DROP INDEX IF EXISTS rdf_quads_gspo;
-        DROP INDEX IF EXISTS rdf_quads_gpos;
-        DROP INDEX IF EXISTS rdf_quads_source;
-        DROP TABLE IF EXISTS rdf_quads;
-        DROP TABLE IF EXISTS rdf_sources;
-        DROP TABLE IF EXISTS rdf_terms;
-        DROP TABLE IF EXISTS rdf_index_metadata;
-      `);
-            (0, Rdf3xSchema_1.dropRdf3xDerivedSchemaObjects)(db);
-        }
-        finally {
-            if (foreignKeys) {
-                db.exec('PRAGMA foreign_keys = ON;');
-            }
-        }
-        this.cardinalityCache.clear();
+        const row = db.prepare(`
+      SELECT COUNT(*) AS count
+      FROM sqlite_schema
+      WHERE name IN ('rdf_terms', 'rdf_sources', 'rdf_quads', 'rdf_index_metadata')
+         OR tbl_name IN ('rdf_terms', 'rdf_sources', 'rdf_quads', 'rdf_index_metadata')
+    `).get();
+        return (row?.count ?? 0) > 0;
     }
     bumpDataVersion() {
-        this.requireDb().prepare(`
-      INSERT INTO rdf_index_metadata (key, value)
-      VALUES ('data_version', '1')
-      ON CONFLICT (key)
-      DO UPDATE SET value = CAST(value AS INTEGER) + 1
+        const result = this.requireDb().prepare(`
+      UPDATE rdf_index_metadata
+      SET value = CAST(value AS INTEGER) + 1
+      WHERE key = 'data_version'
     `).run();
-    }
-    setMetadataValue(key, value) {
-        this.requireDb().prepare(`
-      INSERT INTO rdf_index_metadata (key, value)
-      VALUES (?, ?)
-      ON CONFLICT (key)
-      DO UPDATE SET value = excluded.value
-    `).run(key, value);
+        if (result.changes !== 1) {
+            throw new Error('Unsupported RDF facts schema: missing data_version metadata');
+        }
     }
     upsertSource(source) {
         const db = this.requireDb();
+        this.requireDictionary().getOrCreate(n3_1.DataFactory.namedNode(source.source));
         db.prepare(`
       INSERT INTO rdf_sources (
         source,
@@ -1195,6 +1321,7 @@ class RdfQuadIndex {
         return row.id;
     }
     updateSourceRow(id, source) {
+        this.requireDictionary().getOrCreate(n3_1.DataFactory.namedNode(source.source));
         this.requireDb().prepare(`
       UPDATE rdf_sources
       SET source = ?,
@@ -1232,6 +1359,7 @@ class RdfQuadIndex {
                 equalityColumns.add(column);
             }
         }
+        this.addSourceScopeConditions(pattern.sourceScope, 'rdf_quads', 'source_scope', joins, conditions, params, queryPlan);
         return {
             joins: joins.join(''),
             whereClause: conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '',
@@ -1240,6 +1368,59 @@ class RdfQuadIndex {
             queryPlan,
         };
     }
+    addSourceScopeConditions(scope, quadAlias, aliasPrefix, joins, conditions, params, queryPlan) {
+        if (!scope) {
+            return;
+        }
+        const allowedSources = uniqueStrings(scope.allowedSources ?? []);
+        const deniedSources = uniqueStrings(scope.deniedSources ?? []);
+        const deniedPrefixes = uniqueStrings(scope.deniedSourcePrefixes ?? []);
+        const sourcePrefix = scope.sourcePrefix;
+        const localPathPrefix = scope.localPathPrefix;
+        if (allowedSources.length === 0
+            && !scope.allowedSources
+            && deniedSources.length === 0
+            && deniedPrefixes.length === 0
+            && !sourcePrefix
+            && !localPathPrefix) {
+            return;
+        }
+        if (scope.allowedSources && allowedSources.length === 0) {
+            conditions.push('1 = 0');
+            queryPlan.push('SourceScope(allowed:none)');
+            return;
+        }
+        const sourceAlias = this.scopedSqlName('rdf_sources', { aliasPrefix });
+        const sourceIdColumn = `${quadAlias}.source_file_id`;
+        joins.push(` LEFT JOIN rdf_sources ${sourceAlias} ON ${sourceAlias}.id = ${sourceIdColumn}`);
+        if (allowedSources.length > 0) {
+            conditions.push(`${sourceAlias}.source IN (${allowedSources.map(() => '?').join(', ')})`);
+            params.push(...allowedSources);
+            queryPlan.push(`SourceScope(allowed:${allowedSources.length})`);
+        }
+        if (sourcePrefix) {
+            conditions.push(`${sourceAlias}.source LIKE ? ESCAPE '\\'`);
+            params.push(`${escapeLikePattern(sourcePrefix)}%`);
+            queryPlan.push('SourceScope(prefix)');
+        }
+        if (localPathPrefix) {
+            conditions.push(`${sourceAlias}.local_path LIKE ? ESCAPE '\\'`);
+            params.push(`${escapeLikePattern(localPathPrefix)}%`);
+            queryPlan.push('SourceScope(local-path-prefix)');
+        }
+        if (deniedSources.length > 0) {
+            conditions.push(`(${sourceIdColumn} IS NULL OR ${sourceAlias}.source NOT IN (${deniedSources.map(() => '?').join(', ')}))`);
+            params.push(...deniedSources);
+            queryPlan.push(`SourceScope(denied:${deniedSources.length})`);
+        }
+        for (const deniedPrefix of deniedPrefixes) {
+            conditions.push(`(${sourceIdColumn} IS NULL OR ${sourceAlias}.source NOT LIKE ? ESCAPE '\\')`);
+            params.push(`${escapeLikePattern(deniedPrefix)}%`);
+        }
+        if (deniedPrefixes.length > 0) {
+            queryPlan.push(`SourceScope(denied-prefix:${deniedPrefixes.length})`);
+        }
+    }
     matchToCondition(key, column, match, allowUnresolved, scope) {
         const columnRef = this.scopedQuadColumn(column, scope);
         if ((0, types_1.isTerm)(match)) {
@@ -1794,6 +1975,9 @@ class RdfQuadIndex {
         return 'full-scan';
     }
     exactTermPattern(pattern) {
+        if (pattern.sourceScope) {
+            return undefined;
+        }
         const ids = {};
         const columns = new Set();
         for (const key of TERM_KEYS) {
@@ -2042,6 +2226,9 @@ function escapeLikePattern(value) {
 function uniqueNumbers(values) {
     return [...new Set(values)];
 }
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.length > 0))].sort();
+}
 function uniquePatternKeys(values) {
     return TERM_KEYS.filter((key) => values.includes(key));
 }

package/dist/storage/rdf/RdfQuadIndex.jsonld

@@ -111,14 +111,6 @@
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_dataVersion",
           "memberFieldName": "dataVersion"
         },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_migrationState",
-          "memberFieldName": "migrationState"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_setMigrationState",
-          "memberFieldName": "setMigrationState"
-        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_scan",
           "memberFieldName": "scan"
@@ -268,29 +260,21 @@
           "memberFieldName": "estimatePageSize"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_initializeSchema",
-          "memberFieldName": "initializeSchema"
-        },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_prepareSchemaVersion",
-          "memberFieldName": "prepareSchemaVersion"
+          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_prepareFactsSchema",
+          "memberFieldName": "prepareFactsSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_ensureMetadataTable",
-          "memberFieldName": "ensureMetadataTable"
+          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_createFreshFactsSchema",
+          "memberFieldName": "createFreshFactsSchema"
         },
         {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_dropIndexSchema",
-          "memberFieldName": "dropIndexSchema"
+          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_hasExistingFactsSchema",
+          "memberFieldName": "hasExistingFactsSchema"
         },
         {
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_bumpDataVersion",
           "memberFieldName": "bumpDataVersion"
         },
-        {
-          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_setMetadataValue",
-          "memberFieldName": "setMetadataValue"
-        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_upsertSource",
           "memberFieldName": "upsertSource"
@@ -303,6 +287,10 @@
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_buildWhereClause",
           "memberFieldName": "buildWhereClause"
         },
+        {
+          "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_addSourceScopeConditions",
+          "memberFieldName": "addSourceScopeConditions"
+        },
         {
           "@id": "undefineds:dist/storage/rdf/RdfQuadIndex.jsonld#RdfQuadIndex__member_matchToCondition",
           "memberFieldName": "matchToCondition"

package/dist/storage/rdf/RdfQueryExecutor.js

@@ -1058,6 +1058,7 @@ class RdfQueryExecutor {
     }
     canUseRdf3xPrimaryScan(pattern, scanOptions) {
         return Boolean(this.rdf3xPrimaryIndex)
+            && !pattern.sourceScope
             && isRdf3xCompatiblePattern(pattern);
     }
     requiredBgpPushdown(query, requiredPatterns, filters) {
@@ -1216,7 +1217,7 @@ class RdfQueryExecutor {
     canUseRdf3xPrimaryJoin(patterns) {
         return Boolean(this.rdf3xPrimaryIndex)
             && patterns.length > 0
-            && patterns.every((entry) => isRdf3xCompatiblePattern(entry.pattern));
+            && patterns.every((entry) => !entry.pattern.sourceScope && isRdf3xCompatiblePattern(entry.pattern));
     }
     tupleValuesForBinding(source, binding) {
         if (!source.tupleValues) {
@@ -1932,6 +1933,7 @@ class RdfQueryExecutor {
         return isConsistentPattern(compiled)
             ? {
                 ...compiled,
+                ...(pattern.sourceScope ? { sourceScope: pattern.sourceScope } : {}),
                 pushedDownFilters: pushedDownFilterIndexes.size,
                 pushedDownFilterIndexes: [...pushedDownFilterIndexes],
             }
@@ -2582,9 +2584,10 @@ function normalizeOptionalGroup(group) {
     return Array.isArray(group) ? { patterns: group } : group;
 }
 function compiledPatternKey(pattern) {
-    return TERM_KEYS
-        .map((key) => `${key}:${termMatchKey(pattern[key])}`)
-        .join('|');
+    return [
+        ...TERM_KEYS.map((key) => `${key}:${termMatchKey(pattern[key])}`),
+        `source:${JSON.stringify(pattern.sourceScope ?? {})}`,
+    ].join('|');
 }
 function termMatchKey(match) {
     if (!match) {
@@ -3212,6 +3215,9 @@ function stripRdf3xNumericAggregateGuards(patterns, aggregates) {
     });
 }
 function isRdf3xCompatiblePattern(pattern) {
+    if (pattern.sourceScope) {
+        return false;
+    }
     return TERM_KEYS.every((key) => {
         const value = pattern[key];
         if (!value || (0, types_1.isTerm)(value)) {

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

@@ -0,0 +1,33 @@
+import type { AsyncIterator } from 'asynciterator';
+import type { BindingsStream } from '@comunica/types';
+import type { Quad, Variable } from '@rdfjs/types';
+import type { SparqlEngine, SparqlQueryOptions, SparqlVoidOptions } from '../sparql/SubgraphQueryEngine';
+import { type RdfAccessScope } from './RdfAccessScope';
+import type { RdfEngineLike } from './types';
+type RdfBindingsStream = BindingsStream & {
+    metadata(): Promise<{
+        variables: Variable[];
+    }>;
+};
+/**
+ * Public Cloud SPARQL authority.
+ *
+ * Comunica is the sole SPARQL algebra evaluator. Every RDF/JS source match is
+ * translated into an access-scoped query against the PostgreSQL RDF facts
+ * authority; there is no second evaluator or alternate per-query route.
+ */
+export declare class RdfQuerySparqlEngine implements SparqlEngine {
+    private readonly rdfEngine;
+    private readonly comunica;
+    constructor(rdfEngine: RdfEngineLike);
+    queryBindings(query: string, basePath: string, accessScope?: RdfAccessScope, options?: SparqlQueryOptions): Promise<RdfBindingsStream>;
+    queryBoolean(query: string, basePath: string, accessScope?: RdfAccessScope, options?: SparqlQueryOptions): Promise<boolean>;
+    queryQuads(query: string, basePath: string, accessScope?: RdfAccessScope, options?: SparqlQueryOptions): Promise<AsyncIterator<Quad>>;
+    queryVoid(_query: string, _basePath: string, _accessScope?: RdfAccessScope, _options?: SparqlVoidOptions): Promise<void>;
+    constructGraph(graph: string, basePath: string, accessScope?: RdfAccessScope): Promise<AsyncIterator<Quad>>;
+    listGraphs(basePath: string, accessScope?: RdfAccessScope): Promise<Set<string>>;
+    close(): Promise<void>;
+    private context;
+    private assertCloudQuery;
+}
+export {};