jinaga-server 2.1.8 → 2.2.0

package/src/postgres/specification-sql.ts

@@ -53,7 +53,7 @@ class QueryDescription {
         private readonly notExistsConditions: NotExistsConditionDescription[] = []
     ) {}
 
-    generateSqlQuery(bookmark: string, limit: number): SpecificationSqlQuery {
+    generateSqlQuery(schema: string, bookmark: string, limit: number): SpecificationSqlQuery {
         const hashes = this.outputs
             .map(output => `f${output.factIndex}.hash as hash${output.factIndex}`)
             .join(", ");
@@ -65,17 +65,17 @@ class QueryDescription {
         const successorFact = this.inputs.find(i => i.factIndex === firstEdge.successorFactIndex);
         const firstFactIndex = predecessorFact ? predecessorFact.factIndex : successorFact!.factIndex;
         const writtenFactIndexes = new Set<number>().add(firstFactIndex);
-        const joins: string[] = generateJoins(this.edges, writtenFactIndexes);
+        const joins: string[] = generateJoins(schema, this.edges, writtenFactIndexes);
         const inputWhereClauses = this.inputs
             .filter(input => input.factTypeParameter !== 0)
             .map(input => `f${input.factIndex}.fact_type_id = $${input.factTypeParameter} AND f${input.factIndex}.hash = $${input.factHashParameter}`)
             .join(" AND ");
         const notExistsWhereClauses = this.notExistsConditions
-            .map(notExistsWhereClause => ` AND NOT EXISTS (${generateNotExistsWhereClause(notExistsWhereClause, writtenFactIndexes)})`)
+            .map(notExistsWhereClause => ` AND NOT EXISTS (${generateNotExistsWhereClause(schema, notExistsWhereClause, writtenFactIndexes)})`)
             .join("");
         const bookmarkParameter = this.parameters.length + 1;
         const limitParameter = bookmarkParameter + 1;
-        const sql = `SELECT ${hashes}, sort(array[${factIds}], 'desc') as bookmark FROM public.fact f${firstFactIndex}${joins.join("")} WHERE ${inputWhereClauses}${notExistsWhereClauses} AND sort(array[${factIds}], 'desc') > $${bookmarkParameter} ORDER BY bookmark ASC LIMIT $${limitParameter}`;
+        const sql = `SELECT ${hashes}, sort(array[${factIds}], 'desc') as bookmark FROM ${schema}.fact f${firstFactIndex}${joins.join("")} WHERE ${inputWhereClauses}${notExistsWhereClauses} AND sort(array[${factIds}], 'desc') > $${bookmarkParameter} ORDER BY bookmark ASC LIMIT $${limitParameter}`;
         const bookmarkValue: number[] = parseBookmark(bookmark);
         return {
             sql,
@@ -89,13 +89,13 @@ class QueryDescription {
     }
 }
 
-function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>) {
+function generateJoins(schema: string, edges: EdgeDescription[], writtenFactIndexes: Set<number>) {
     const joins: string[] = [];
     edges.forEach(edge => {
         if (writtenFactIndexes.has(edge.predecessorFactIndex)) {
             if (writtenFactIndexes.has(edge.successorFactIndex)) {
                 joins.push(
-                    ` JOIN public.edge e${edge.edgeIndex}` +
+                    ` JOIN ${schema}.edge e${edge.edgeIndex}` +
                     ` ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id` +
                     ` AND e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id` +
                     ` AND e${edge.edgeIndex}.role_id = $${edge.roleParameter}`
@@ -103,12 +103,12 @@ function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>
             }
             else {
                 joins.push(
-                    ` JOIN public.edge e${edge.edgeIndex}` +
+                    ` JOIN ${schema}.edge e${edge.edgeIndex}` +
                     ` ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id` +
                     ` AND e${edge.edgeIndex}.role_id = $${edge.roleParameter}`
                 );
                 joins.push(
-                    ` JOIN public.fact f${edge.successorFactIndex}` +
+                    ` JOIN ${schema}.fact f${edge.successorFactIndex}` +
                     ` ON f${edge.successorFactIndex}.fact_id = e${edge.edgeIndex}.successor_fact_id`
                 );
                 writtenFactIndexes.add(edge.successorFactIndex);
@@ -116,12 +116,12 @@ function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>
         }
         else if (writtenFactIndexes.has(edge.successorFactIndex)) {
             joins.push(
-                ` JOIN public.edge e${edge.edgeIndex}` +
+                ` JOIN ${schema}.edge e${edge.edgeIndex}` +
                 ` ON e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id` +
                 ` AND e${edge.edgeIndex}.role_id = $${edge.roleParameter}`
             );
             joins.push(
-                ` JOIN public.fact f${edge.predecessorFactIndex}` +
+                ` JOIN ${schema}.fact f${edge.predecessorFactIndex}` +
                 ` ON f${edge.predecessorFactIndex}.fact_id = e${edge.edgeIndex}.predecessor_fact_id`
             );
             writtenFactIndexes.add(edge.predecessorFactIndex);
@@ -133,7 +133,7 @@ function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>
     return joins;
 }
 
-function generateNotExistsWhereClause(notExistsWhereClause: NotExistsConditionDescription, outerFactIndexes: Set<number>): string {
+function generateNotExistsWhereClause(schema: string, notExistsWhereClause: NotExistsConditionDescription, outerFactIndexes: Set<number>): string {
     const firstEdge = notExistsWhereClause.edges[0];
     const writtenFactIndexes = new Set<number>(outerFactIndexes);
     const firstJoin: string[] = [];
@@ -148,7 +148,7 @@ function generateNotExistsWhereClause(notExistsWhereClause: NotExistsConditionDe
                 ` AND e${firstEdge.edgeIndex}.role_id = $${firstEdge.roleParameter}`
             );
             firstJoin.push(
-                ` JOIN public.fact f${firstEdge.successorFactIndex}` +
+                ` JOIN ${schema}.fact f${firstEdge.successorFactIndex}` +
                 ` ON f${firstEdge.successorFactIndex}.fact_id = e${firstEdge.edgeIndex}.successor_fact_id`
             );
             writtenFactIndexes.add(firstEdge.successorFactIndex);
@@ -160,7 +160,7 @@ function generateNotExistsWhereClause(notExistsWhereClause: NotExistsConditionDe
             ` AND e${firstEdge.edgeIndex}.role_id = $${firstEdge.roleParameter}`
         );
         firstJoin.push(
-            ` JOIN public.fact f${firstEdge.predecessorFactIndex}` +
+            ` JOIN ${schema}.fact f${firstEdge.predecessorFactIndex}` +
             ` ON f${firstEdge.predecessorFactIndex}.fact_id = e${firstEdge.edgeIndex}.predecessor_fact_id`
         );
         writtenFactIndexes.add(firstEdge.predecessorFactIndex);
@@ -168,9 +168,9 @@ function generateNotExistsWhereClause(notExistsWhereClause: NotExistsConditionDe
     else {
         throw new Error("Neither predecessor nor successor fact has been written");
     }
-    const tailJoins: string[] = generateJoins(notExistsWhereClause.edges.slice(1), writtenFactIndexes);
+    const tailJoins: string[] = generateJoins(schema, notExistsWhereClause.edges.slice(1), writtenFactIndexes);
     const joins = firstJoin.concat(tailJoins);
-    return `SELECT 1 FROM public.edge e${firstEdge.edgeIndex}${joins.join("")} WHERE ${whereClause.join(" AND ")}`;
+    return `SELECT 1 FROM ${schema}.edge e${firstEdge.edgeIndex}${joins.join("")} WHERE ${whereClause.join(" AND ")}`;
 }
 
 function parseBookmark(bookmark: string): number[] {
@@ -330,7 +330,7 @@ class DescriptionBuilder {
     }
 }
 
-export function sqlFromSpecification(start: FactReference[], bookmarks: string[], limit: number, specification: Specification, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery[] {
+export function sqlFromSpecification(start: FactReference[], schema: string, bookmarks: string[], limit: number, specification: Specification, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery[] {
     const feeds = buildFeeds(start, specification);
     const descriptionBuilder = new DescriptionBuilder(factTypes, roleMap);
     const feedAndBookmark = feeds.map((feed, index) => ({
@@ -341,18 +341,18 @@ export function sqlFromSpecification(start: FactReference[], bookmarks: string[]
         descriptionBuilder.isSatisfiable(fb.feed, fb.feed.edges));
     const sqlQueries = satisfiableFeedsAndBookmarks.map(fb => {
         const description = descriptionBuilder.buildDescription(fb.feed);
-        const sql = description.generateSqlQuery(fb.bookmark, limit);
+        const sql = description.generateSqlQuery(schema, fb.bookmark, limit);
         return sql;
     });
     return sqlQueries;
 }
 
-export function sqlFromFeed(feed: Feed, bookmark: string, limit: number, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery | null {
+export function sqlFromFeed(feed: Feed, schema: string, bookmark: string, limit: number, factTypes: Map<string, number>, roleMap: Map<number, Map<string, number>>): SpecificationSqlQuery | null {
     const descriptionBuilder = new DescriptionBuilder(factTypes, roleMap);
     if (!descriptionBuilder.isSatisfiable(feed, feed.edges)) {
         return null;
     }
     const description = descriptionBuilder.buildDescription(feed);
-    const sql = description.generateSqlQuery(bookmark, limit);
+    const sql = description.generateSqlQuery(schema, bookmark, limit);
     return sql;
 }

package/src/postgres/sql.ts

@@ -10,10 +10,10 @@ export type SqlQuery = {
     factTypeNames: string[]
 };
 
-export function sqlFromSteps(start: FactReference, steps: Step[], factTypes: FactTypeMap, roleMap: RoleMap) : SqlQuery | null {
+export function sqlFromSteps(start: FactReference, steps: Step[], factTypes: FactTypeMap, roleMap: RoleMap, schema: string) : SqlQuery | null {
     const builder = new QueryBuilder(factTypes, roleMap);
 
-    return builder.buildQuery(start, steps);
+    return builder.buildQuery(start, steps, schema);
 }
 
 interface QueryJoinEdge {
@@ -90,7 +90,7 @@ class QueryBuilder {
     constructor(private factTypes: FactTypeMap, private roleMap: RoleMap) {
     }
 
-    buildQuery(start: FactReference, steps: Step[]): SqlQuery | null {
+    buildQuery(start: FactReference, steps: Step[], schema: string): SqlQuery | null {
         if (steps.length === 0) {
             return null;
         }
@@ -120,9 +120,9 @@ class QueryBuilder {
             .filter(j => j.table === 'fact')
             .map(j => (j as QueryJoinFact).factAlias);
         const hashes = factAliases.map(a => `f${a}.hash as hash${a}`).join(', ');
-        const joins = this.buildJoins(this.queryParts.joins, 'f1.fact_id');
-        const whereClause = this.buildWhereClause(this.queryParts.existentialClauses);
-        const sql = `SELECT ${hashes} FROM public.fact f1${joins} WHERE f1.fact_type_id = $1 AND f1.hash = $2${whereClause}`;
+        const joins = this.buildJoins(schema, this.queryParts.joins, 'f1.fact_id');
+        const whereClause = this.buildWhereClause(schema, this.queryParts.existentialClauses);
+        const sql = `SELECT ${hashes} FROM ${schema}.fact f1${joins} WHERE f1.fact_type_id = $1 AND f1.hash = $2${whereClause}`;
 
         return {
             empty: false,
@@ -133,7 +133,7 @@ class QueryBuilder {
         };
     }
 
-    private buildJoins(joins: QueryJoin[], priorFactId: string) {
+    private buildJoins(schema: string, joins: QueryJoin[], priorFactId: string) {
         interface Joins {
             priorFactId: string,
             clauses: string[]
@@ -145,7 +145,7 @@ class QueryBuilder {
         const clauses = joins.reduce((joins, join) => {
             if (join.table === 'edge') {
                 if (join.direction === 'successor') {
-                    const clause = ` JOIN public.edge e${join.edgeAlias} ` +
+                    const clause = ` JOIN ${schema}.edge e${join.edgeAlias} ` +
                         `ON e${join.edgeAlias}.predecessor_fact_id = ${joins.priorFactId} ` +
                         `AND e${join.edgeAlias}.role_id = $${join.roleParameter}`;
                     return {
@@ -154,7 +154,7 @@ class QueryBuilder {
                     };
                 }
                 else {
-                    const clause = ` JOIN public.edge e${join.edgeAlias} ` +
+                    const clause = ` JOIN ${schema}.edge e${join.edgeAlias} ` +
                         `ON e${join.edgeAlias}.successor_fact_id = ${joins.priorFactId} ` +
                         `AND e${join.edgeAlias}.role_id = $${join.roleParameter}`;
                     return {
@@ -163,7 +163,7 @@ class QueryBuilder {
                     };
                 }
             } else {
-                const clause = ` JOIN public.fact f${join.factAlias} ON f${join.factAlias}.fact_id = ${joins.priorFactId}`;
+                const clause = ` JOIN ${schema}.fact f${join.factAlias} ON f${join.factAlias}.fact_id = ${joins.priorFactId}`;
                 return {
                     priorFactId: joins.priorFactId,
                     clauses: [...joins.clauses, clause]
@@ -173,7 +173,7 @@ class QueryBuilder {
         return clauses.join('');
     }
 
-    buildWhereClause(existentialClauses: ExistentialClause[]): string {
+    buildWhereClause(schema: string, existentialClauses: ExistentialClause[]): string {
         if (existentialClauses.length === 0) {
             return '';
         }
@@ -187,12 +187,12 @@ class QueryBuilder {
             const firstTailFactId = first.direction === 'predecessor'
                 ? `e${first.edgeAlias}.successor_fact_id`
                 : `e${first.edgeAlias}.predecessor_fact_id`;
-            const joins = this.buildJoins(rest, firstHeadFactId);
+            const joins = this.buildJoins(schema, rest, firstHeadFactId);
             const priorFactId = clause.priorEdgeJoin.direction === 'predecessor'
                 ? `e${clause.priorEdgeJoin.edgeAlias}.predecessor_fact_id`
                 : `e${clause.priorEdgeJoin.edgeAlias}.successor_fact_id`;
-            const whereClause = this.buildWhereClause(clause.query.existentialClauses);
-            return ` AND ${quantifierSql} (SELECT 1 FROM public.edge e${first.edgeAlias}${joins} ` +
+            const whereClause = this.buildWhereClause(schema, clause.query.existentialClauses);
+            return ` AND ${quantifierSql} (SELECT 1 FROM ${schema}.edge e${first.edgeAlias}${joins} ` +
                 `WHERE ${firstTailFactId} = ${priorFactId} ` +
                 `AND e${first.edgeAlias}.role_id = $${first.roleParameter}${whereClause})`;
         });

package/test/postgres/postgresReadSpec.ts

@@ -43,7 +43,7 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
         }
         throw new Error(`Unknown input type ${input.type}`);
     });
-    const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap);
+    const composer = resultSqlFromSpecification(start, specification, factTypes, roleMap, "public");
     if (!composer) {
         throw new Error("The specification is not satisfiable.");
     }

package/test/postgres/postgresSpec.ts

@@ -27,7 +27,7 @@ describe('Postgres', () => {
     let roleMap = allRoles(query.steps, 'Root').filter(r => r.type !== 'Unknown' && r.role !== 'unknown').reduce(
       (r, role, i) => addRole(r, ensureGetFactTypeId(factTypes, role.type), role.role, i + 1),
       emptyRoleMap());
-    const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap);
+    const sqlQuery = sqlFromSteps(start, query.steps, factTypes, roleMap, "public");
     return sqlQuery ? { sql: sqlQuery.sql, parameters: sqlQuery.parameters, pathLength: sqlQuery.pathLength, empty: sqlQuery.empty, factTypes, roleMap } : null;
   }
 

package/test/postgres/postgresSpecificationSpec.ts

@@ -44,7 +44,7 @@ function sqlFor(descriptiveString: string, bookmarks: string[] = []) {
         }
         throw new Error(`Unknown input type ${input.type}`);
     });
-    const sqlQueries = sqlFromSpecification(start, bookmarks, 100, specification, factTypes, roleMap);
+    const sqlQueries = sqlFromSpecification(start, "public", bookmarks, 100, specification, factTypes, roleMap);
     return { sqlQueries, factTypes, roleMap };
 }