@mason-data/cli 0.8.0 → 0.10.0

package/dist/src/duck/row-filter.js

@@ -18,9 +18,10 @@
  * string, a quoted name, a dollar-quoted body and a comment, never in a `::` cast.
  */
 import { deparseSync } from "pgsql-deparser";
-import { gapRefusal, StatementError } from "../api/postgres/server.js";
+import { gapRefusal, StatementError } from "./statement.js";
 import { parseSql } from "../api/postgres/parser.js";
 import { analyze, catalogRows } from "./analyze.js";
+import { sessionSetSql } from "../api/postgres/catalog.js";
 import { treeDifference } from "./rewrite.js";
 /** an attribute's name: what `:name` reads and `--set name=value` sets */
 export const ATTRIBUTE_NAME_RE = /^[a-z_][a-z0-9_]{0,62}$/;
@@ -183,7 +184,7 @@ export async function filterTypes(run, f, shapes) {
         const message = (r.M ?? "Postgres refused it").replace(/\$(\d+)/g, (m, k) => names[Number(k) - 1] !== undefined ? `:${names[Number(k) - 1]}` : m);
         return { problem: `${f.at}.where: ${message}${at} — the predicate is checked by Postgres as SELECT 1 FROM ${f.table} WHERE ${f.where.text}` };
     };
-    const first = await analyze(run, sql, names.map(() => 0), "public");
+    const first = await analyze(run, sql, names.map(() => 0));
     if ("refused" in first)
         return said(first.refused);
     if (hasSubquery(first.tree))
@@ -215,7 +216,7 @@ export async function filterTypes(run, f, shapes) {
     }
     if (mismatch !== null) {
         // Postgres's own refusal, the parameter declared of the shape the file says
-        const again = await analyze(run, sql, declared, "public");
+        const again = await analyze(run, sql, declared);
         if ("refused" in again)
             return { problem: `${said(again.refused).problem} (${mismatch})` };
         return { problem: `${f.at}.where: ${mismatch}` };
@@ -278,7 +279,7 @@ export function bindFilter(f, types, values) {
 export async function attributeRefused(run, rows, tables) {
     for (const table of tables) {
         for (const a of rows.get(table)?.attributes ?? []) {
-            const r = await analyze(run, `SELECT ${a.sql}`, [], "public");
+            const r = await analyze(run, `SELECT ${a.sql}`, []);
             if ("refused" in r)
                 return { name: a.name, type: a.type, at: a.at, where: a.where, problem: r.refused.M ?? "Postgres refused it" };
         }
@@ -544,7 +545,7 @@ async function carryKeyDependency(catalog, tree, reads, analysis, oids) {
  * security: a filtered table's whole row (a subquery's is a record), a name both a WITH query and a filtered table, a
  * TABLESAMPLE of one, a column qualified by its schema beside another item of the table's name.
  */
-export async function expandRowFilters(catalog, stmt, analysis, searchPathSql, filters) {
+export async function expandRowFilters(catalog, stmt, analysis, under, filters) {
     const read = relationsRead(analysis.tree);
     if (read.size === 0 || filters.size === 0)
         return null;
@@ -562,7 +563,7 @@ export async function expandRowFilters(catalog, stmt, analysis, searchPathSql, f
     const ranges = all.filter((n) => n.kind === "RangeVar");
     const ctes = new Set(all.filter((n) => n.kind === "CommonTableExpr").map((n) => n.body.ctename));
     const spelled = ranges.map((r) => [r.body.catalogname, r.body.schemaname, r.body.relname].filter((x) => typeof x === "string").map(quoteIdent).join("."));
-    const resolved = spelled.length === 0 ? [] : await catalogRows(catalog, `SET LOCAL search_path = ${searchPathSql}, pg_catalog; SELECT v.i::text, c.oid::text FROM (VALUES ${spelled.map((s, i) => `(${i}, ${literal(s)})`).join(", ")}) AS v(i, name) ` +
+    const resolved = spelled.length === 0 ? [] : await catalogRows(catalog, `${sessionSetSql(under, true)}; SELECT v.i::text, c.oid::text FROM (VALUES ${spelled.map((s, i) => `(${i}, ${literal(s)})`).join(", ")}) AS v(i, name) ` +
         `JOIN pg_class c ON c.oid = to_regclass(v.name) WHERE c.relkind = 'r'`);
     const asFiltered = new Map();
     for (const [i, oid] of resolved) {
@@ -591,6 +592,11 @@ export async function expandRowFilters(catalog, stmt, analysis, searchPathSql, f
     if ([...filteredRead.values()].some((v) => !found.has(v.table))) {
         throw refused("Mason could not tell which of the statement's names are the tables its role filters (a Mason gap: report it, with the statement)", "write each table's name qualified by its schema");
     }
+    // the printer below (pgsql-deparser) writes FETCH … WITH TIES as a LIMIT, which the read-back refuses as a report-it
+    // gap: said by name here instead, at any depth (a set operation's arm is a body of its own, unwrapped)
+    if (JSON.stringify(tree).includes("\"limitOption\":\"LIMIT_OPTION_WITH_TIES\"")) {
+        throw refused("Mason cannot yet answer FETCH … WITH TIES in a statement that reads a table its role filters", "write ORDER BY … LIMIT n where the ties do not matter");
+    }
     // a column qualified by its table's schema (`public.orders.id`, Metabase writes every column so) names the subquery by
     // its alias alone: sound only where no other item of the statement has the table's name
     const named = all.flatMap((n) => {

package/dist/src/duck/statement.js

@@ -0,0 +1,19 @@
+import { gapMark } from "./gaps.js";
+/** A statement's error as Postgres raises it, from outside the listener (the DuckDB runner's): the fields, and the SQL
+ *  its position is in. */
+export class StatementError extends Error {
+    fields;
+    sql;
+    /** the registry entry (src/duck/gaps.ts) that refused the statement, as the refusal was built with it (`gapRefusal`,
+     *  src/duck/store.ts pgErrorOf): what the request log records as `gap`; null for every other error */
+    gap;
+    constructor(fields, sql = "", gap = null) { super(fields.message); this.fields = fields; this.sql = sql; this.gap = gap; }
+}
+/**
+ * A REFUSAL BY A REGISTRY ENTRY (src/duck/gaps.ts), the one way one is built: 0A000, `Mason gap <id>` in its DETAIL (what
+ * the oracle and a reader read), followed by `detail` (docs/SQL-SUPPORT.md, or what it names), and the id itself on the
+ * error, so the request log records which entry refused it without reading the text back.
+ */
+export function gapRefusal(gap, message, hint, sql = "", detail = " (docs/SQL-SUPPORT.md)") {
+    return new StatementError({ code: "0A000", message, hint, detail: `${gapMark(gap)}${detail}` }, sql, gap);
+}