@memberjunction/generic-database-provider 5.28.0 → 5.30.0

package/dist/queryCompositionEngine.js

@@ -1,7 +1,8 @@
 import { UUIDsEqual } from "@memberjunction/global";
-import { SQLServerDialect, PostgreSQLDialect } from "@memberjunction/sql-dialect";
-import { SQLParser } from "@memberjunction/sql-parser";
+import { GetDialect } from "@memberjunction/sql-dialect";
+import { SQLParser, AnalyzeTopLevelOrderBy } from "@memberjunction/sql-parser";
 import { Metadata, QueryInfo } from "@memberjunction/core";
+import { SymbolTable } from "./symbolTable.js";
 /**
  * Maximum depth for recursive query composition resolution.
  * Prevents runaway recursion from deeply nested compositions.
@@ -92,12 +93,9 @@ export class QueryCompositionEngine {
         if (hasCompositions) {
             finalSQL = this.assembleCTEs(cteEntries, resolvedSQL, platform);
         }
-        // If any dependency uses templates, Nunjucks will run on the resolved SQL.
-        // Neutralize any {{ }} patterns inside SQL comments so Nunjucks doesn't
-        // try to parse them as template expressions (e.g. -- Demonstrates {{query:"..."}}).
-        if (templateFlag.value) {
-            finalSQL = this.escapeTemplateTokensInComments(finalSQL);
-        }
+        // Comment-embedded {{ }} tokens (e.g. -- Example: {{query:"..."}}) are
+        // handled by the pipeline: RenderPipeline strips SQL comments before
+        // Nunjucks runs, so they never reach the template evaluator.
         return {
             ResolvedSQL: finalSQL,
             CTEs: cteEntries.map(e => e.Info),
@@ -146,8 +144,13 @@ export class QueryCompositionEngine {
                 resolvedSQL = resolvedSQL.replace(token.FullToken, existingCTE.CTEName);
                 continue;
             }
-            // Get platform-specific SQL for the referenced query
-            const refSQL = referencedQuery.GetPlatformSQL(platform);
+            // Get platform-specific SQL for the referenced query.
+            // Strip SQL comments immediately — they serve no runtime purpose and
+            // can contain {{ }} patterns that confuse substituteStaticParams,
+            // Nunjucks, or ORDER BY detection. The pipeline also strips comments
+            // from the outer query before Nunjucks, but dep SQL enters here
+            // before it reaches the pipeline's comment-stripping step.
+            const refSQL = this.stripSQLComments(referencedQuery.GetPlatformSQL(platform));
             // Substitute static parameter values directly into the referenced query's SQL
             const paramSubstitutedSQL = this.substituteStaticParams(refSQL, resolvedParams);
             // Track in-progress for cycle detection
@@ -369,11 +372,7 @@ export class QueryCompositionEngine {
      * Resolves a DatabasePlatform string to the corresponding SQLDialect instance.
      */
     getDialect(platform) {
-        switch (platform) {
-            case 'postgresql': return new PostgreSQLDialect();
-            case 'sqlserver': return new SQLServerDialect();
-            default: throw new Error(`Unsupported database platform: ${platform}`);
-        }
+        return GetDialect(platform);
     }
     /**
      * Simple string hash for generating short, deterministic suffixes.
@@ -405,30 +404,24 @@ export class QueryCompositionEngine {
     assembleCTEs(cteEntries, mainSQL, platform) {
         if (cteEntries.length === 0)
             return mainSQL;
-        // Check if the main SQL already starts with a WITH clause
         const trimmedMain = mainSQL.trimStart();
         const startsWithWith = /^WITH\s/i.test(trimmedMain);
         const dialect = this.getDialect(platform);
-        // Track every CTE name allocated to the assembled WITH (case-insensitive).
-        // We seed with the outer-CTE names from the entries themselves so that an
-        // inner CTE happening to share a name with another entry's outer CTE
-        // also gets renamed.
-        const allocatedNames = new Set(cteEntries.map(e => this.canonicalCTEName(e.CTEName).toLowerCase()));
-        // Build CTE definitions, hoisting any inner WITH clauses from dependency SQL
+        // SymbolTable guarantees CTE name uniqueness at registration time.
+        const symTable = new SymbolTable(dialect);
+        // Seed the symbol table with outer-CTE names so inner CTEs that happen
+        // to share a name with an outer CTE also get renamed.
+        for (const entry of cteEntries) {
+            symTable.Seed(this.canonicalCTEName(entry.CTEName));
+        }
         const cteDefinitions = [];
         for (const entry of cteEntries) {
             const strippedSQL = this.stripTrailingOrderBy(entry.SQL, dialect);
-            // Strip SQL comments before checking for WITH, because dependency queries
-            // may have comment headers (-- or /* */) before the WITH clause.
             const commentStrippedSQL = this.stripSQLComments(strippedSQL).trimStart();
             if (/^WITH\s/i.test(commentStrippedSQL)) {
-                // Dependency SQL has its own WITH clause — hoist inner CTEs as siblings.
-                // Pass the comment-stripped version so ExtractCTEs can detect the WITH prefix.
-                const { innerCTEDefinitions, mainSelect } = this.hoistInnerCTEs(commentStrippedSQL, platform);
-                // Rename any inner CTE whose name collides with an already-
-                // allocated name. Rewrites references in (a) other inner CTEs of
-                // this same dep (siblings), and (b) the dep's mainSelect.
-                const { definitions, rewrittenMainSelect } = this.deconflictInnerCTEs(innerCTEDefinitions, mainSelect, allocatedNames);
+                const { innerCTEDefinitions, mainSelect } = this.hoistInnerCTEs(commentStrippedSQL, dialect);
+                // Use SymbolTable for deconfliction instead of raw Set
+                const { definitions, rewrittenMainSelect } = this.deconflictInnerCTEsViaSymbolTable(innerCTEDefinitions, mainSelect, symTable);
                 cteDefinitions.push(...definitions);
                 cteDefinitions.push(`${entry.CTEName} AS (\n${rewrittenMainSelect}\n)`);
             }
@@ -436,14 +429,43 @@ export class QueryCompositionEngine {
                 cteDefinitions.push(`${entry.CTEName} AS (\n${strippedSQL}\n)`);
             }
         }
+        if (!dialect.AllowsOrderByInCTE) {
+            this.validateCTEBodies(cteDefinitions, cteEntries, dialect);
+        }
         if (startsWithWith) {
-            // Main SQL has its own WITH — merge by removing the leading WITH
-            // and prepending our CTEs before it
             const mainWithoutWith = trimmedMain.replace(/^WITH\s+/i, '');
             return `WITH ${cteDefinitions.join(',\n')},\n${mainWithoutWith}`;
         }
         return `WITH ${cteDefinitions.join(',\n')}\n${mainSQL}`;
     }
+    /**
+     * Validates that no CTE body still contains an illegal top-level ORDER BY
+     * after stripping. Throws a diagnostic error with the dep name, category
+     * path, and specific reason — replacing the cryptic SQL Server error
+     * "The ORDER BY clause is invalid in views, inline functions...".
+     */
+    validateCTEBodies(cteDefinitions, cteEntries, dialect) {
+        for (const def of cteDefinitions) {
+            // Extract the CTE body between the first "(" and the last ")"
+            const bodyMatch = def.match(/^([^\s]+)\s+AS\s*\(\n?([\s\S]*?)\n?\)$/i);
+            if (!bodyMatch)
+                continue;
+            const cteName = bodyMatch[1];
+            const body = bodyMatch[2];
+            const analysis = AnalyzeTopLevelOrderBy(body, dialect);
+            if (analysis.Positions.length > 0 && !analysis.IsLegalInCTE) {
+                const entry = cteEntries.find(e => e.CTEName === cteName);
+                const depName = entry?.Info.QueryName ?? cteName;
+                const categoryPath = entry?.Info.CategoryPath ?? '';
+                const position = analysis.Positions[analysis.Positions.length - 1];
+                throw new Error(`Composition error: dependency '${depName}'` +
+                    (categoryPath ? ` (${categoryPath})` : '') +
+                    ` has a trailing ORDER BY at position ${position} that could not be stripped. ` +
+                    `SQL Server does not allow ORDER BY in CTEs without TOP, OFFSET, or FOR XML. ` +
+                    `Either remove the ORDER BY from the dependency, or add TOP/OFFSET.`);
+            }
+        }
+    }
     /**
      * Strips the surrounding bracket / quote characters from a CTE name so we
      * can compare names case-insensitively across quoting styles. `[Foo]`,
@@ -453,61 +475,39 @@ export class QueryCompositionEngine {
         return rawName.replace(/^[\["]|[\]"]$/g, '');
     }
     /**
-     * Walks `innerCTEDefinitions` (each formatted as `Name AS (\nbody\n)` by
-     * `extractCTEsViaRegex`/`extractCTEsViaAST`) and ensures every CTE name is
-     * unique across the assembled WITH. When a collision is detected, the inner
-     * CTE is renamed (`Name` → `Name__2`, `__3`, …) and the new name is
-     * substituted everywhere the original was referenced — both in subsequent
-     * inner CTE bodies (siblings can reference each other) and in the dep's
-     * main SELECT.
+     * Deconflicts inner CTE names using a SymbolTable for name allocation.
+     * The SymbolTable guarantees uniqueness at registration time — name
+     * collisions become impossible by construction.
      *
-     * NOTE (Phase 0 trade-off): reference rewriting is a word-boundary regex
-     * over raw SQL. It does NOT skip string literals or comments. Real
-     * dependencies' inner-CTE names are unlikely to appear as quoted text or
-     * column aliases, so this is acceptable for the immediate fix; the
-     * IR-based redesign (see plans/query-rendering-pipeline-redesign.md)
-     * replaces this with a structured walk.
+     * Reference rewriting uses word-boundary regex over raw SQL. It does
+     * NOT skip string literals or comments — inner-CTE names are unlikely
+     * to appear as quoted text or column aliases in practice.
      */
-    deconflictInnerCTEs(innerCTEDefinitions, mainSelect, allocatedNames) {
-        // Pre-compute renames first, so all sibling/main-select rewrites use
-        // the final names regardless of definition order.
-        const renames = new Map(); // canonical-old → new bare name
+    deconflictInnerCTEsViaSymbolTable(innerCTEDefinitions, mainSelect, symTable) {
+        const renames = new Map();
         const finalDefinitionHeaders = [];
         for (const def of innerCTEDefinitions) {
             const headerMatch = def.match(/^(\[[^\]]+\]|"[^"]+"|[A-Za-z_]\w*)(\s+AS\s*\()/i);
             if (!headerMatch) {
-                // Couldn't parse — leave untouched. Future allocations may
-                // still collide, but this preserves existing behavior.
                 finalDefinitionHeaders.push({ original: def, rewritten: def });
                 continue;
             }
             const rawName = headerMatch[1];
             const canonical = this.canonicalCTEName(rawName);
-            const lower = canonical.toLowerCase();
-            if (!allocatedNames.has(lower)) {
-                allocatedNames.add(lower);
-                finalDefinitionHeaders.push({ original: def, rewritten: def });
-                continue;
+            // SymbolTable.Register handles collision detection + suffix generation
+            const actual = symTable.Register(canonical);
+            if (actual !== canonical) {
+                renames.set(canonical, actual);
+                const rewrittenDef = actual + headerMatch[2] + def.substring(headerMatch[0].length);
+                finalDefinitionHeaders.push({ original: def, rewritten: rewrittenDef });
             }
-            // Collision — find a fresh name.
-            let suffix = 2;
-            let candidate = `${canonical}__${suffix}`;
-            while (allocatedNames.has(candidate.toLowerCase())) {
-                suffix++;
-                candidate = `${canonical}__${suffix}`;
+            else {
+                finalDefinitionHeaders.push({ original: def, rewritten: def });
             }
-            allocatedNames.add(candidate.toLowerCase());
-            renames.set(canonical, candidate);
-            // Replace just the header on the definition; the body will be
-            // rewritten in the next pass alongside other deps' references.
-            const rewrittenDef = candidate + headerMatch[2] + def.substring(headerMatch[0].length);
-            finalDefinitionHeaders.push({ original: def, rewritten: rewrittenDef });
         }
         if (renames.size === 0) {
             return { definitions: finalDefinitionHeaders.map(d => d.rewritten), rewrittenMainSelect: mainSelect };
         }
-        // Apply all renames to every inner CTE body and the main SELECT, so
-        // sibling CTEs that reference the renamed CTE point at the new name.
         const rewriteAll = (sql) => {
             let result = sql;
             for (const [oldName, newName] of renames) {
@@ -525,7 +525,7 @@ export class QueryCompositionEngine {
      * `MyAcronymBridge` is not affected by renaming `AcronymBridge`.
      *
      * Does not attempt to skip string literals or comments — see the note on
-     * `deconflictInnerCTEs` for the trade-off rationale.
+     * `deconflictInnerCTEsViaSymbolTable` for the trade-off rationale.
      */
     renameSQLIdentifier(sql, oldName, newName) {
         const escaped = oldName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -541,10 +541,9 @@ export class QueryCompositionEngine {
      * AST parsing fails (e.g. SQL contains Nunjucks template tokens).
      *
      * @param sql SQL starting with a WITH clause
-     * @param platform Database platform, used to select the AST dialect
+     * @param dialect SQL dialect for AST parsing
      */
-    hoistInnerCTEs(sql, platform) {
-        const dialect = platform === 'postgresql' ? 'PostgresQL' : 'TransactSQL';
+    hoistInnerCTEs(sql, dialect) {
         const extraction = SQLParser.ExtractCTEs(sql, dialect);
         if (!extraction) {
             // Should not happen since caller already verified WITH prefix,
@@ -562,17 +561,13 @@ export class QueryCompositionEngine {
      * SQL Server disallows ORDER BY inside CTEs unless TOP, OFFSET, or FOR XML is present.
      * PostgreSQL allows ORDER BY in CTEs, so no stripping is needed there.
      *
-     * Uses a 4-tier strategy:
-     * 1. Fast exit — no ORDER keyword at all, or dialect allows ORDER BY in CTEs
-     * 2. AST path — parse (with Nunjucks preprocessing if needed), check if ORDER BY is legal
-     *    (TOP/OFFSET/FOR XML via AST nodes), null out orderby if not, regenerate.
-     *    Handles window functions, UNION/EXCEPT, subqueries, string literals, and Nunjucks templates.
-     * 3. Regex fallback — paren-depth heuristic for SQL the parser still can't handle
-     *    (e.g. STRING_AGG WITHIN GROUP)
-     * 4. OFFSET 0 ROWS injection — last resort when both AST and regex fail to strip ORDER BY.
-     *    Injects OFFSET 0 ROWS after the ORDER BY clause to make it legal in CTEs.
-     *    This is semantically neutral (returns all rows starting from 0) but switches
-     *    SQL Server into paging mode internally, which may affect query plan shape.
+     * Delegates to the shared `AnalyzeTopLevelOrderBy` utility (orderByAnalyzer.ts)
+     * which implements a 2-tier strategy:
+     *   Tier 1: AST parsing (with Nunjucks preprocessing if needed)
+     *   Tier 2: MJLexer scanner with carried lexical state across token boundaries
+     *
+     * When both tiers fail to strip, falls back to OFFSET 0 ROWS injection as
+     * a last resort (semantically neutral but makes ORDER BY legal in CTEs).
      */
     stripTrailingOrderBy(sql, dialect) {
         if (!sql)
@@ -582,241 +577,28 @@ export class QueryCompositionEngine {
             return sql;
         if (dialect.AllowsOrderByInCTE)
             return sql;
-        // Tier 2: AST-based stripping
-        const astResult = this.stripOrderByViaAST(trimmed, dialect.ParserDialect);
-        if (astResult !== null)
-            return astResult;
-        // Tier 3: Position-aware fallback (skips comments, strings, MJ tokens via MJLexer)
-        const regexResult = this.stripOrderByViaRegex(trimmed);
-        if (regexResult !== trimmed)
-            return regexResult;
-        // Tier 4: OFFSET 0 ROWS injection — last resort, but ONLY when a real
-        // top-level ORDER BY exists. If there is none, returning SQL unchanged is
-        // correct; injecting OFFSET 0 ROWS would itself be an error
-        // (OFFSET requires ORDER BY in the same query level).
-        if (this.findTopLevelOrderByPositions(trimmed).length === 0) {
+        const analysis = AnalyzeTopLevelOrderBy(trimmed, dialect);
+        // No top-level ORDER BY found — nothing to strip
+        if (analysis.Positions.length === 0)
             return sql;
-        }
-        return this.injectOffset0Rows(trimmed);
-    }
-    /**
-     * Attempts to strip the top-level ORDER BY clause using AST parsing.
-     * Tries direct parsing first, then MJPlaceholder-preprocessed parsing if the SQL
-     * contains MJ template syntax. Handles UNION/EXCEPT by walking the _next chain.
-     */
-    stripOrderByViaAST(sql, parserDialect) {
-        const directResult = this.tryASTStrip(sql, parserDialect);
-        if (directResult !== null)
-            return directResult;
-        // Check for MJ extensions using MJLexer (replaces regex check)
-        const mjParse = SQLParser.Analyze(sql);
-        if (mjParse.hasMJExtensions) {
-            return this.tryNunjucksAwareStrip(sql, parserDialect);
-        }
-        return null;
-    }
-    /**
-     * Core AST stripping: parse, analyze, and regenerate SQL without ORDER BY.
-     */
-    tryASTStrip(sql, parserDialect) {
-        try {
-            // Use SQLParser.ParseSQL for FOR XML multi-directive workaround
-            const ast = SQLParser.ParseSQL(sql, parserDialect);
-            if (!ast)
-                return null;
-            const stmt = Array.isArray(ast) ? ast[0] : ast;
-            if (!stmt)
-                return sql;
-            const stmtRecord = stmt;
-            const orderByStmt = this.findOrderByStatement(stmtRecord);
-            if (!orderByStmt)
-                return sql;
-            if (this.isOrderByLegalInCTE(orderByStmt))
-                return sql;
-            orderByStmt.orderby = null;
-            return SQLParser.SqlifyAST(Array.isArray(ast) ? ast : [stmt], parserDialect);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Walks the _next chain (UNION/EXCEPT/INTERSECT) to find the statement
-     * that carries the ORDER BY clause.
-     */
-    findOrderByStatement(stmt) {
-        if (stmt.orderby)
-            return stmt;
-        if (stmt._next)
-            return this.findOrderByStatement(stmt._next);
-        return null;
-    }
-    /**
-     * Nunjucks-aware ORDER BY stripping: preprocess templates into placeholder SQL,
-     * parse with AST to confirm top-level ORDER BY exists, then use the position-aware
-     * scanner on the original SQL to strip only the last top-level ORDER BY.
-     */
-    tryNunjucksAwareStrip(sql, parserDialect) {
-        const preprocessed = this.preprocessNunjucks(sql);
-        try {
-            const ast = SQLParser.ParseSQL(preprocessed, parserDialect);
-            if (!ast)
-                return null;
-            const stmt = Array.isArray(ast) ? ast[0] : ast;
-            if (!stmt)
-                return sql;
-            const stmtRecord = stmt;
-            const orderByStmt = this.findOrderByStatement(stmtRecord);
-            if (!orderByStmt)
-                return sql;
-            if (this.isOrderByLegalInCTE(orderByStmt))
-                return sql;
-            return this.stripLastTopLevelOrderBy(sql);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Checks AST properties to determine if ORDER BY is legal in a CTE context.
-     */
-    isOrderByLegalInCTE(stmt) {
-        if (stmt.top)
-            return true;
-        if (stmt.limit)
-            return true;
-        const forClause = stmt.for;
-        if (forClause && typeof forClause === 'object' && forClause.type &&
-            String(forClause.type).toLowerCase().includes('xml')) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Strips the last top-level ORDER BY clause using position-aware scanning.
-     * Skips strings, comments, Nunjucks tags, and tracks paren depth.
-     */
-    stripLastTopLevelOrderBy(sql) {
-        const positions = this.findTopLevelOrderByPositions(sql);
-        if (positions.length === 0)
+        // ORDER BY is legal in this CTE context (TOP/OFFSET/FOR XML)
+        if (analysis.IsLegalInCTE)
             return sql;
-        const lastPos = positions[positions.length - 1];
-        return sql.substring(0, lastPos).trimEnd();
-    }
-    /**
-     * Finds character positions of all ORDER BY keywords at the outermost level
-     * (paren depth 0, not inside strings, comments, or MJ template tokens).
-     *
-     * Uses MJLexer to skip MJ tokens ({{ }}, {% %}, {# #}), then scans only
-     * SQL_TEXT segments for ORDER BY keywords while tracking paren depth and
-     * respecting SQL string literals and comments.
-     */
-    findTopLevelOrderByPositions(sql) {
-        const tokens = SQLParser.Tokenize(sql);
-        const positions = [];
-        let parenDepth = 0;
-        for (const token of tokens) {
-            // Only scan SQL_TEXT tokens — MJ tokens are skipped entirely
-            if (token.type !== 'SQL_TEXT')
-                continue;
-            const text = token.raw;
-            let i = 0;
-            while (i < text.length) {
-                const ch = text[i];
-                // Skip single-quoted string literals
-                if (ch === "'") {
-                    i++;
-                    while (i < text.length) {
-                        if (text[i] === "'" && i + 1 < text.length && text[i + 1] === "'") {
-                            i += 2;
-                        }
-                        else if (text[i] === "'") {
-                            i++;
-                            break;
-                        }
-                        else {
-                            i++;
-                        }
-                    }
-                    continue;
-                }
-                // Skip line comments
-                if (ch === '-' && i + 1 < text.length && text[i + 1] === '-') {
-                    while (i < text.length && text[i] !== '\n')
-                        i++;
-                    continue;
-                }
-                // Skip block comments
-                if (ch === '/' && i + 1 < text.length && text[i + 1] === '*') {
-                    i += 2;
-                    while (i < text.length) {
-                        if (text[i] === '*' && i + 1 < text.length && text[i + 1] === '/') {
-                            i += 2;
-                            break;
-                        }
-                        i++;
-                    }
-                    continue;
-                }
-                if (ch === '(') {
-                    parenDepth++;
-                    i++;
-                    continue;
-                }
-                if (ch === ')') {
-                    parenDepth--;
-                    i++;
-                    continue;
-                }
-                if (parenDepth === 0 && /^ORDER\s+BY\b/i.test(text.substring(i))) {
-                    const absPos = token.start + i;
-                    if (absPos === 0 || /[\s,;()\n]/.test(sql[absPos - 1])) {
-                        positions.push(absPos);
-                    }
-                }
-                i++;
-            }
-        }
-        return positions;
-    }
-    /**
-     * Preprocesses Nunjucks templates into valid SQL for AST parsing.
-     * Uses MJPlaceholderSubstitution for context-aware placeholder generation.
-     */
-    preprocessNunjucks(sql) {
-        return SQLParser.Substitute(sql).cleanSQL;
+        // Stripping succeeded — use the stripped SQL
+        if (analysis.SqlWithoutOrderBy !== trimmed)
+            return analysis.SqlWithoutOrderBy;
+        // Last resort: OFFSET 0 ROWS injection
+        return this.injectOffset0Rows(trimmed);
     }
     /**
      * Injects OFFSET 0 ROWS after the last top-level ORDER BY clause to make it
-     * legal in a CTE without changing the result set. Uses the position-aware scanner
-     * to find the correct insertion point after the ORDER BY columns.
+     * legal in a CTE without changing the result set.
      */
     injectOffset0Rows(sql) {
-        // Find the end of the last top-level ORDER BY clause.
-        // We append OFFSET 0 ROWS right at the end of the SQL.
         const trimmed = sql.trimEnd();
-        // Remove trailing semicolon if present
         const withoutSemicolon = trimmed.replace(/;\s*$/, '');
         return `${withoutSemicolon} OFFSET 0 ROWS`;
     }
-    /**
-     * Position-aware fallback for stripping the last top-level ORDER BY clause.
-     * Delegates to `stripLastTopLevelOrderBy`, which uses MJLexer to skip MJ
-     * template tokens, then scans only SQL_TEXT segments while respecting paren
-     * depth, single-quoted string literals, line comments (--), and block
-     * comments (/* … *​/).
-     *
-     * The previous regex-only implementation matched any literal "ORDER BY" in
-     * the SQL — including text inside leading block comments like
-     * `/* No ORDER BY / TOP — composable. *​/` — and truncated the dep body
-     * mid-comment, producing illegal SQL ("Incorrect syntax near '('").
-     * Skip-Brain hit this against multiple AGRiP composition deps. See
-     * `__tests__/skip-failure-regressions.test.ts` and
-     * `SKIP-QUERY-RENDERING-BUGS.md` (Bug A) at the repo root.
-     */
-    stripOrderByViaRegex(sql) {
-        return this.stripLastTopLevelOrderBy(sql);
-    }
     /**
      * Strips SQL comments from the input string so that composition tokens
      * inside comments are not treated as real references.
@@ -870,64 +652,5 @@ export class QueryCompositionEngine {
         }
         return result;
     }
-    /**
-     * Escapes {{ and }} inside SQL comments so that Nunjucks doesn't try to parse them.
-     * This is needed because dependency queries may carry comments containing
-     * {{query:"..."}} examples or documentation that would otherwise cause
-     * Nunjucks "expected variable end" errors.
-     *
-     * Only modifies content inside -- single-line and block comments.
-     * Leaves string literals and normal SQL untouched.
-     */
-    escapeTemplateTokensInComments(sql) {
-        let result = '';
-        let i = 0;
-        while (i < sql.length) {
-            // Single-quoted string literal — preserve as-is
-            if (sql[i] === "'") {
-                result += sql[i++];
-                while (i < sql.length) {
-                    if (sql[i] === "'" && i + 1 < sql.length && sql[i + 1] === "'") {
-                        result += "''";
-                        i += 2;
-                    }
-                    else if (sql[i] === "'") {
-                        result += sql[i++];
-                        break;
-                    }
-                    else {
-                        result += sql[i++];
-                    }
-                }
-            }
-            // Single-line comment: -- to end of line — escape {{ and }} inside
-            else if (sql[i] === '-' && i + 1 < sql.length && sql[i + 1] === '-') {
-                let comment = '';
-                while (i < sql.length && sql[i] !== '\n') {
-                    comment += sql[i++];
-                }
-                result += comment.replace(/\{\{/g, '{ {').replace(/\}\}/g, '} }');
-            }
-            // Block comment: /* ... */ — escape {{ and }} inside
-            else if (sql[i] === '/' && i + 1 < sql.length && sql[i + 1] === '*') {
-                let comment = '/*';
-                i += 2;
-                while (i < sql.length) {
-                    if (sql[i] === '*' && i + 1 < sql.length && sql[i + 1] === '/') {
-                        comment += '*/';
-                        i += 2;
-                        break;
-                    }
-                    comment += sql[i++];
-                }
-                result += comment.replace(/\{\{/g, '{ {').replace(/\}\}/g, '} }');
-            }
-            // Normal character
-            else {
-                result += sql[i++];
-            }
-        }
-        return result;
-    }
 }
 //# sourceMappingURL=queryCompositionEngine.js.map