jinaga-server 3.7.5 → 3.8.1

package/src/http/router.ts

@@ -41,6 +41,13 @@ import { outputReadResultsStreaming } from "./output-formatters";
 import { arrayToResultStream, ResultStream } from "./result-stream";
 import { Stream } from "./stream";
 
+// A streaming response reports itself twice: one line when the stream opens
+// and one when it ends, carrying the messages sent, how long it lasted, and
+// what ended it. Issue #192: the per-message and per-lifecycle-step lines this
+// replaces made the log grow with traffic rather than with the number of events
+// worth knowing about, and `STREAM DONE`'s message count already said what the
+// per-message lines said one at a time. A plain GET says nothing at all, since
+// Trace.dependency already records it. Failures still log.
 function getOrStream<U>(
     getMethod: ((req: RequestUser, params: { [key: string]: string }, query: qs.ParsedQs) => Promise<U | null>),
     streamMethod: ((req: RequestUser, params: { [key: string]: string }, query: qs.ParsedQs) => Promise<Stream<U> | null>)
@@ -49,75 +56,68 @@ function getOrStream<U>(
         const connectionId = Math.random().toString(36).substring(2, 10);
         const user = <RequestUser>(req as any).user;
         const accept = req.headers["accept"];
-        
-        console.log(`[HttpConnection:${connectionId}] New request - User: ${user?.id || 'anonymous'}, Accept: ${accept}, URL: ${req.url}`);
-        
+
         if (accept && accept.indexOf("application/x-jinaga-feed-stream") >= 0) {
-            console.log(`[HttpConnection:${connectionId}] STREAMING request detected`);
-            
             streamMethod(user, req.params, req.query)
                 .then(response => {
                     if (!response) {
-                        console.log(`[HttpConnection:${connectionId}] Stream method returned null - sending 404`);
                         sendRouteMiss(res);
                         next();
                     }
                     else {
-                        console.log(`[HttpConnection:${connectionId}] Setting up streaming response`);
-                        
                         res.type("application/x-jinaga-feed-stream");
                         res.set("Connection", "keep-alive");
                         res.set("Cache-Control", "no-cache");
                         res.set("Access-Control-Allow-Origin", "*");
                         res.flushHeaders();
-                        
-                        console.log(`[HttpConnection:${connectionId}] Headers flushed - setting up event handlers`);
-                        
+
+                        const openedAt = Date.now();
+                        console.log(`[HttpConnection:${connectionId}] Stream opened - User: ${user?.id || 'anonymous'}, URL: ${req.url}`);
+
                         let clientDisconnected = false;
-                        let timeoutTriggered = false;
                         let streamClosed = false;
-                        
+                        // What closed the stream from outside, where something
+                        // other than the feed itself closed it. One value
+                        // rather than a flag per cause, because a stream ends
+                        // exactly once and only the first cause is the reason.
+                        let closedBy: "client disconnect" | "timeout" | null = null;
+
                         // Client disconnect handler
                         req.on("close", () => {
-                            console.log(`[HttpConnection:${connectionId}] CLIENT DISCONNECTED`);
                             clientDisconnected = true;
                             if (!streamClosed) {
-                                console.log(`[HttpConnection:${connectionId}] Closing stream due to client disconnect`);
-                                response.close();
+                                closedBy = "client disconnect";
                                 streamClosed = true;
+                                response.close();
                             }
                         });
-                        
+
                         // Timeout handler
                         const timeout = setTimeout(() => {
-                            console.log(`[HttpConnection:${connectionId}] TIMEOUT TRIGGERED (5 minutes)`);
-                            timeoutTriggered = true;
                             if (!streamClosed) {
-                                console.log(`[HttpConnection:${connectionId}] Closing stream due to timeout`);
-                                response.close();
+                                closedBy = "timeout";
                                 streamClosed = true;
+                                response.close();
                             }
                         }, 5 * 60 * 1000);
-                        
+
                         let messageCount = 0;
-                        
+
                         response
                             .next(data => {
                                 messageCount++;
                                 const writeStart = Date.now();
-                                
+
                                 if (clientDisconnected) {
                                     console.warn(`[HttpConnection:${connectionId}] Attempted to write to disconnected client - Message #${messageCount}`);
                                     return;
                                 }
-                                
+
                                 try {
                                     const jsonData = JSON.stringify(data) + "\n\n";
                                     res.write(jsonData);
                                     const writeDuration = Date.now() - writeStart;
-                                    
-                                    console.log(`[HttpConnection:${connectionId}] Message #${messageCount} sent - Size: ${jsonData.length} bytes, Duration: ${writeDuration}ms`);
-                                    
+
                                     if (writeDuration > 50) {
                                         console.warn(`[HttpConnection:${connectionId}] SLOW write operation - Duration: ${writeDuration}ms`);
                                     }
@@ -126,24 +126,19 @@ function getOrStream<U>(
                                 }
                             })
                             .done(() => {
-                                console.log(`[HttpConnection:${connectionId}] STREAM DONE - Messages sent: ${messageCount}, Client disconnected: ${clientDisconnected}, Timeout triggered: ${timeoutTriggered}`);
-                                
                                 clearTimeout(timeout);
                                 streamClosed = true;
-                                
+
+                                console.log(`[HttpConnection:${connectionId}] Stream ended - Messages sent: ${messageCount}, Duration: ${Date.now() - openedAt}ms, Reason: ${closedBy ?? "done"}`);
+
                                 try {
                                     if (!clientDisconnected) {
-                                        console.log(`[HttpConnection:${connectionId}] Ending socket connection`);
                                         res.socket?.end();
-                                    } else {
-                                        console.log(`[HttpConnection:${connectionId}] Client already disconnected - skipping socket end`);
                                     }
                                 } catch (error) {
                                     console.error(`[HttpConnection:${connectionId}] ERROR ending socket: ${error}`);
                                 }
                             });
-                        
-                        console.log(`[HttpConnection:${connectionId}] Stream handlers configured`);
                     }
                 })
                 .catch(error => {
@@ -152,16 +147,13 @@ function getOrStream<U>(
                 });
         }
         else {
-            console.log(`[HttpConnection:${connectionId}] Regular GET request`);
             getMethod(user, req.params, req.query)
                 .then(response => {
                     if (!response) {
-                        console.log(`[HttpConnection:${connectionId}] Get method returned null - sending 404`);
                         sendRouteMiss(res);
                         next();
                     }
                     else {
-                        console.log(`[HttpConnection:${connectionId}] Sending JSON response`);
                         res.type("json");
                         res.send(JSON.stringify(response));
                         next();

package/src/http/stream.ts

@@ -1,14 +1,18 @@
+// This class logs nothing on its success path. A stream's lifetime is reported
+// once by the request that opened it (see getOrStream in router.ts), and a line
+// per feed, per replayed item, or per done handler says the same thing again
+// once per unit of traffic. Issue #192: those per-item lines were 11.9% of a
+// 2.8-million-line production log. Failures still log, because a failed handler
+// is an event an operator cannot reconstruct from the summary.
 export class Stream<T> {
     private queue: T[] = [];
     private handlers: ((data: T) => void)[] = [];
     private doneHandlers: (() => void)[] = [];
     private closed = false;
     private readonly streamId: string;
-    private feedCount = 0;
 
     constructor() {
         this.streamId = Math.random().toString(36).substring(2, 10);
-        console.log(`[Stream:${this.streamId}] Created new stream`);
     }
 
     next(handler: (data: T) => void): Stream<T> {
@@ -16,21 +20,18 @@ export class Stream<T> {
             console.warn(`[Stream:${this.streamId}] Attempted to add handler to closed stream`);
             return this;
         }
-        
+
         this.handlers.push(handler);
-        const queueLength = this.queue.length;
-        console.log(`[Stream:${this.streamId}] Added handler - Total handlers: ${this.handlers.length}, Queued items: ${queueLength}`);
-        
+
         // Replay queued data to new handler
         this.queue.forEach((data, index) => {
             try {
                 handler(data);
-                console.log(`[Stream:${this.streamId}] Replayed queued item ${index + 1}/${queueLength} to new handler`);
             } catch (error) {
                 console.error(`[Stream:${this.streamId}] Error replaying queued item ${index + 1}: ${error}`);
             }
         });
-        
+
         return this;
     }
 
@@ -44,9 +45,8 @@ export class Stream<T> {
             }
             return this;
         }
-        
+
         this.doneHandlers.push(handler);
-        console.log(`[Stream:${this.streamId}] Added done handler - Total done handlers: ${this.doneHandlers.length}`);
         return this;
     }
 
@@ -55,70 +55,55 @@ export class Stream<T> {
             console.warn(`[Stream:${this.streamId}] Attempted to close already closed stream`);
             return;
         }
-        
-        console.log(`[Stream:${this.streamId}] CLOSING stream - Handlers: ${this.handlers.length}, Done handlers: ${this.doneHandlers.length}, Queue: ${this.queue.length}, Feed count: ${this.feedCount}`);
-        
+
         this.closed = true;
-        
+
         // Execute done handlers
-        const doneHandlerCount = this.doneHandlers.length;
         this.doneHandlers.forEach((handler, index) => {
             try {
                 handler();
-                console.log(`[Stream:${this.streamId}] Executed done handler ${index + 1}/${doneHandlerCount}`);
             } catch (error) {
                 console.error(`[Stream:${this.streamId}] Error in done handler ${index + 1}: ${error}`);
             }
         });
-        
+
         // Clear all references
         this.queue = [];
         this.handlers = [];
         this.doneHandlers = [];
-        
-        console.log(`[Stream:${this.streamId}] Stream closed and cleaned up`);
     }
 
     feed(data: any): void {
         const feedStart = Date.now();
-        
+
         if (this.closed) {
             console.warn(`[Stream:${this.streamId}] Attempted to feed data to closed stream - Data type: ${typeof data}`);
             return;
         }
-        
-        this.feedCount++;
+
         const handlerCount = this.handlers.length;
-        
-        console.log(`[Stream:${this.streamId}] FEEDING data - Feed #${this.feedCount}, Handlers: ${handlerCount}, Queue size before: ${this.queue.length}`);
-        
+
         this.queue.push(data);
-        
+
         // Notify all handlers
-        let successCount = 0;
-        let errorCount = 0;
-        
         this.handlers.forEach((handler, index) => {
             try {
                 const handlerStart = Date.now();
                 handler(data);
                 const handlerDuration = Date.now() - handlerStart;
-                successCount++;
-                
+
                 if (handlerDuration > 50) {
                     console.warn(`[Stream:${this.streamId}] SLOW handler - Handler ${index + 1}/${handlerCount}, Duration: ${handlerDuration}ms`);
                 }
             } catch (error) {
-                errorCount++;
                 console.error(`[Stream:${this.streamId}] ERROR in handler ${index + 1}/${handlerCount}: ${error}`);
             }
         });
-        
+
         const totalDuration = Date.now() - feedStart;
-        console.log(`[Stream:${this.streamId}] Feed complete - Success: ${successCount}, Errors: ${errorCount}, Queue size after: ${this.queue.length}, Duration: ${totalDuration}ms`);
-        
+
         if (totalDuration > 100) {
             console.warn(`[Stream:${this.streamId}] SLOW feed operation - Duration: ${totalDuration}ms`);
         }
     }
-}
+}

package/src/jinaga-server.ts

@@ -253,22 +253,82 @@ function getPool(uriOrPool: string | Pool, pools: { [uri: string]: Pool; }): Poo
     }
 }
 
+type PoolSettingDeclaration = {
+    variable: string,
+    defaultValue: number,
+    minimum: number
+};
+
+// The settings of a pool that this server builds for itself, each named by the
+// environment variable that sets it. A pool the caller supplies is used as
+// given, so none of these applies to it.
+const poolSettingDeclarations = {
+    // A pool of zero connections can serve nothing, so one is the minimum.
+    max: { variable: "POSTGRES_POOL_MAX", defaultValue: 10, minimum: 1 },
+    idleTimeoutMillis: { variable: "POSTGRES_IDLE_TIMEOUT_MILLIS", defaultValue: 30000, minimum: 0 },
+    // Zero means wait forever for a connection to come free.
+    connectionTimeoutMillis: { variable: "POSTGRES_CONNECTION_TIMEOUT_MILLIS", defaultValue: 0, minimum: 0 }
+} satisfies { [setting: string]: PoolSettingDeclaration };
+
+type PoolSettings = {
+    [setting in keyof typeof poolSettingDeclarations]: number
+};
+
+// The one rule by which every pool setting is read from the environment. An
+// absent or empty variable takes the default; anything that is not an integer
+// at or above the setting's minimum is refused rather than resolved, so the
+// environment either names a pool that can be built or no pool at all.
+function readPoolSetting({ variable, defaultValue, minimum }: PoolSettingDeclaration): number {
+    const value = process.env[variable];
+    if (value === undefined || value.trim() === '') {
+        return defaultValue;
+    }
+    const parsed = /^\d+$/.test(value.trim()) ? parseInt(value.trim(), 10) : NaN;
+    if (isNaN(parsed) || parsed < minimum) {
+        throw new Error(`The environment variable ${variable} is set to ${JSON.stringify(value)}, which is not an integer of at least ${minimum}.`);
+    }
+    return parsed;
+}
+
+function readPoolSettings(): PoolSettings {
+    return {
+        max: readPoolSetting(poolSettingDeclarations.max),
+        idleTimeoutMillis: readPoolSetting(poolSettingDeclarations.idleTimeoutMillis),
+        connectionTimeoutMillis: readPoolSetting(poolSettingDeclarations.connectionTimeoutMillis)
+    };
+}
+
 function createPool(postgresUri: string): Pool {
+    const settings = readPoolSettings();
     const postgresPool = new Pool({
         connectionString: postgresUri,
-        idleTimeoutMillis: process.env.POSTGRES_IDLE_TIMEOUT_MILLIS ?
-            parseInt(process.env.POSTGRES_IDLE_TIMEOUT_MILLIS) :
-            30000,
+        ...settings
     });
 
+    Trace.info(`Postgres pool created with max ${settings.max}, idleTimeoutMillis ${settings.idleTimeoutMillis}, connectionTimeoutMillis ${settings.connectionTimeoutMillis}`);
+
     tracePool(postgresPool);
 
     return postgresPool;
 }
 
+const poolWindowMilliseconds = 10000;
+
 export function tracePool(postgresPool: Pool) {
+    // Pool pressure is reported once per window of time rather than once per
+    // checkout, so the output rate no longer follows the acquire rate and no
+    // longer peaks when the pool is saturated. The window carries the largest
+    // waiting count it saw, so a spike that comes and goes inside one window
+    // still appears in the log.
+    let acquiredInWindow = false;
+    let peakWaiting = 0;
+
     postgresPool.on('acquire', (client) => {
-        Trace.metric('Postgres acquired', poolMetrics());
+        acquiredInWindow = true;
+        observeWaiting();
+    });
+    postgresPool.on('release', (err, client) => {
+        observeWaiting();
     });
     postgresPool.on('connect', (client) => {
         Trace.metric('Postgres connected', poolMetrics());
@@ -280,6 +340,34 @@ export function tracePool(postgresPool: Pool) {
         Trace.error(err);
     });
 
+    // The window closes on a timer so that a storm which stops in the middle
+    // of a window still reports its peak. The timer is unreferenced, so it
+    // does not hold the process open, and it stops once the pool has ended.
+    const windowTimer = setInterval(closeWindow, poolWindowMilliseconds);
+    windowTimer.unref?.();
+
+    function observeWaiting() {
+        if (postgresPool.waitingCount > peakWaiting) {
+            peakWaiting = postgresPool.waitingCount;
+        }
+    }
+
+    function closeWindow() {
+        if (postgresPool.ended) {
+            clearInterval(windowTimer);
+            return;
+        }
+        if (acquiredInWindow) {
+            const metrics = poolMetrics();
+            Trace.metric('Postgres pool', { ...metrics, peakWaiting });
+            if (peakWaiting > 0) {
+                Trace.warn(`Postgres pool saturated: ${peakWaiting} waiting at peak, ${metrics.waiting} waiting of ${metrics.total} at window close.`);
+            }
+        }
+        acquiredInWindow = false;
+        peakWaiting = 0;
+    }
+
     function poolMetrics() {
         return {
             total: postgresPool.totalCount,

package/src/postgres/postgres-store.ts

@@ -44,7 +44,7 @@ import {
 } from "./maps";
 import { ResultSetFact, ResultSetRow, ResultSetTree, resultSqlFromSpecification, SqlQueryTree } from "./specification-result-sql";
 import { sqlFromFeed } from "./specification-sql";
-import { purgeDescendantsSql, purgeSqlFromSpecification } from "./purge-sql";
+import { purgeDescendantsSql, purgeSqlFromSpecifications } from "./purge-sql";
 
 interface PostgresFactRecord extends FactRecord {
     timestamp: Date;  // Maps to date_learned column
@@ -451,12 +451,26 @@ export class PostgresStore implements Storage {
     }
 
     async purge(purgeConditions: Specification[]): Promise<number> {
-        let count = 0;
+        // Purge all conditions on one root type in a single statement,
+        // so that no condition deletes the triggers of another.
+        const conditionsByGivenType = new Map<string, Specification[]>();
         for (const specification of purgeConditions) {
-            const factTypes = await this.loadFactTypesFromSpecification(specification);
-            const roleMap = await this.loadRolesFromSpecification(specification, factTypes);
+            const givenType = specification.given[0].label.type;
+            const group = conditionsByGivenType.get(givenType) ?? [];
+            group.push(specification);
+            conditionsByGivenType.set(givenType, group);
+        }
+
+        let count = 0;
+        for (const specifications of conditionsByGivenType.values()) {
+            let factTypes = this.factTypeMap;
+            let roleMap = this.roleMap;
+            for (const specification of specifications) {
+                factTypes = await this.loadFactTypesFromSpecification(specification);
+                roleMap = await this.loadRolesFromSpecification(specification, factTypes);
+            }
 
-            const purgeCommand = purgeSqlFromSpecification(specification, factTypes, roleMap, this.schema);
+            const purgeCommand = purgeSqlFromSpecifications(specifications, factTypes, roleMap, this.schema);
             if (!purgeCommand) {
                 continue;
             }

package/src/postgres/purge-sql.ts

@@ -43,6 +43,29 @@ export function purgeDescendantsSql(triggerCount: number, schema: string): strin
 
 export function purgeSqlFromSpecification(specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap, schema: string):
     { sql: string, parameters: (string | number)[] } | null {
+    return purgeSqlFromSpecifications([specification], factTypes, roleMap, schema);
+}
+
+/**
+ * Generate one statement that purges under every given purge condition at once.
+ * The conditions must share a given type. Every trigger of every condition,
+ * and every ancestor of those triggers, is spared. Running the conditions one
+ * statement at a time would let one condition delete another's triggers.
+ */
+export function purgeSqlFromSpecifications(specifications: Specification[], factTypes: FactTypeMap, roleMap: RoleMap, schema: string):
+    { sql: string, parameters: (string | number)[] } | null {
+    const queryDescriptions = specifications
+        .map(specification => purgeQueryDescription(specification, factTypes, roleMap))
+        .filter((queryDescription): queryDescription is QueryDescription => queryDescription !== null);
+
+    if (queryDescriptions.length === 0) {
+        return null;
+    }
+
+    return generatePurgeSqlQuery(queryDescriptions, schema);
+}
+
+function purgeQueryDescription(specification: Specification, factTypes: FactTypeMap, roleMap: RoleMap): QueryDescription | null {
     const queryDescriptionBuilder = new QueryDescriptionBuilder(factTypes, roleMap);
 
     let queryDescription = QueryDescription.unsatisfiable;
@@ -71,61 +94,56 @@ export function purgeSqlFromSpecification(specification: Specification, factType
         return null;
     }
 
-    const query = generatePurgeSqlQuery(queryDescription, schema);
-    return query;
-}
-
-
-function generatePurgeSqlQuery(queryDescription: QueryDescription, schema: string):
-    { sql: string, parameters: (string | number)[] } {
     if (queryDescription.existentialConditions.length > 0) {
         throw new Error("Purge conditions should not have existential conditions");
     }
 
-    const columns = queryDescription.outputs
-        .map((label, index) => `f${label.factIndex}.fact_id as trigger${index + 1}`)
-        .join(",\n        ");
-    const firstEdge = queryDescription.edges[0];
-    const predecessorFact = queryDescription.inputs.find(i => i.factIndex === firstEdge.predecessorFactIndex);
-    const successorFact = queryDescription.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(queryDescription.edges, writtenFactIndexes, schema);
-    const inputWhereClauses = queryDescription.inputs
-        .map(input => `f${input.factIndex}.fact_type_id = $${input.factTypeParameter}`)
-        .join(" AND ");
-    const triggerWhereClauses = queryDescription.outputs
-        .map((label, index) => `a.fact_id = c2.trigger${index + 1}`)
-        .join("\n            OR ");
-    const triggerAncestorClauses = queryDescription.outputs
-        .map((label, index) =>
-            `    AND NOT EXISTS (\n` +
-            `        SELECT 1\n` +
-            `        FROM candidates c2\n` +
-            `        JOIN ${schema}.ancestor a2\n` +
-            `            ON a2.fact_id = c2.trigger${index + 1}\n` +
-            `        WHERE a.fact_id = a2.ancestor_fact_id\n` +
-            `    )\n`
-        )
-        .join("");
+    return queryDescription;
+}
+
+function generatePurgeSqlQuery(queryDescriptions: QueryDescription[], schema: string):
+    { sql: string, parameters: (string | number)[] } {
+    const parameters: (string | number)[] = [];
+    const candidateCtes: string[] = [];
+    const rootSelects: string[] = [];
+    const triggerSelects: string[] = [];
+
+    queryDescriptions.forEach((queryDescription, conditionIndex) => {
+        const name = `candidates${conditionIndex + 1}`;
+        const offset = parameters.length;
+        candidateCtes.push(`${name} AS (\n${generateCandidates(queryDescription, offset, schema)})`);
+        // Remove parameter 2, which is the hash of the first fact
+        parameters.push(
+            queryDescription.parameters[0],
+            ...queryDescription.parameters.slice(2)
+        );
+        rootSelects.push(`    SELECT purge_root FROM ${name}\n`);
+        queryDescription.outputs.forEach((label, index) => {
+            triggerSelects.push(`    SELECT trigger${index + 1} AS fact_id FROM ${name}\n`);
+        });
+    });
 
     const sql =
-        `WITH candidates AS (\n` +
-        `    SELECT\n` +
-        `        f${firstFactIndex}.fact_id as purge_root,\n` +
-        `        ${columns}\n` +
-        `    FROM ${schema}.fact f${firstFactIndex}\n${joins.join("")}` +
-        `    WHERE ${inputWhereClauses}\n` +
+        `WITH ${candidateCtes.join(", ")}, roots AS (\n` +
+        rootSelects.join(`    UNION\n`) +
+        `), triggers AS (\n` +
+        triggerSelects.join(`    UNION\n`) +
         `), targets AS (\n` +
         `    SELECT a.fact_id\n` +
         `    FROM ${schema}.ancestor a\n` +
-        `    JOIN candidates c ON c.purge_root = a.ancestor_fact_id\n` +
+        `    JOIN roots r ON r.purge_root = a.ancestor_fact_id\n` +
         `    WHERE NOT EXISTS (\n` +
         `        SELECT 1\n` +
-        `        FROM candidates c2\n` +
-        `        WHERE ${triggerWhereClauses}\n` +
+        `        FROM triggers t\n` +
+        `        WHERE a.fact_id = t.fact_id\n` +
+        `    )\n` +
+        `    AND NOT EXISTS (\n` +
+        `        SELECT 1\n` +
+        `        FROM triggers t\n` +
+        `        JOIN ${schema}.ancestor a2\n` +
+        `            ON a2.fact_id = t.fact_id\n` +
+        `        WHERE a.fact_id = a2.ancestor_fact_id\n` +
         `    )\n` +
-        triggerAncestorClauses +
         `), facts AS (\n` +
         `    DELETE\n` +
         `    FROM ${schema}.fact f\n` +
@@ -133,21 +151,37 @@ function generatePurgeSqlQuery(queryDescription: QueryDescription, schema: strin
         `    RETURNING f.fact_id\n` +
         `)\n` +
         `SELECT fact_id FROM facts\n`;
-    
-    // Remove parameter 1, which is the hash of the first fact
-    const parameters = [
-        queryDescription.parameters[0],
-        ...queryDescription.parameters.slice(2)
-    ];
-        
 
     return {
         sql,
-        parameters: parameters
+        parameters
     };
 }
 
-function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>, schema: string) {
+function generateCandidates(queryDescription: QueryDescription, offset: number, schema: string): string {
+    const columns = queryDescription.outputs
+        .map((label, index) => `f${label.factIndex}.fact_id as trigger${index + 1}`)
+        .join(",\n        ");
+    const firstEdge = queryDescription.edges[0];
+    const predecessorFact = queryDescription.inputs.find(i => i.factIndex === firstEdge.predecessorFactIndex);
+    const successorFact = queryDescription.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(queryDescription.edges, writtenFactIndexes, offset, schema);
+    const inputWhereClauses = queryDescription.inputs
+        .map(input => `f${input.factIndex}.fact_type_id = $${input.factTypeParameter + offset}`)
+        .join(" AND ");
+
+    return (
+        `    SELECT\n` +
+        `        f${firstFactIndex}.fact_id as purge_root,\n` +
+        `        ${columns}\n` +
+        `    FROM ${schema}.fact f${firstFactIndex}\n${joins.join("")}` +
+        `    WHERE ${inputWhereClauses}\n`
+    );
+}
+
+function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>, offset: number, schema: string) {
     const joins: string[] = [];
     edges.forEach(edge => {
         if (writtenFactIndexes.has(edge.predecessorFactIndex)) {
@@ -156,14 +190,14 @@ function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>
                     `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
                     `        ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id\n` +
                     `        AND e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id\n` +
-                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1 + offset}\n`
                 );
             }
             else {
                 joins.push(
                     `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
                     `        ON e${edge.edgeIndex}.predecessor_fact_id = f${edge.predecessorFactIndex}.fact_id\n` +
-                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+                    `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1 + offset}\n`
                 );
                 joins.push(
                     `    JOIN ${schema}.fact f${edge.successorFactIndex}\n` +
@@ -176,7 +210,7 @@ function generateJoins(edges: EdgeDescription[], writtenFactIndexes: Set<number>
             joins.push(
                 `    JOIN ${schema}.edge e${edge.edgeIndex}\n` +
                 `        ON e${edge.edgeIndex}.successor_fact_id = f${edge.successorFactIndex}.fact_id\n` +
-                `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1}\n`
+                `        AND e${edge.edgeIndex}.role_id = $${edge.roleParameter - 1 + offset}\n`
             );
             joins.push(
                 `    JOIN ${schema}.fact f${edge.predecessorFactIndex}\n` +