${escape(s.sql)}`).join('');
+ body = unknownRelationHints(translate.diagnostics) + body + conversionNotes(translate);
body += (translate.diagnostics ?? []).map((d) => terminal(tone(rendered(d, chars)))).join('');
}
const policy = translate.profile ? `policy: ${translate.profile}` : '';
@@ -214,6 +215,67 @@ async function run() {
} else setStage('run', 'skipped', '', refused ? 'nothing was translated' : '');
}
+// What the translation relies on that a reader should know: each known divergence the policy
+// allows (as `sqlquack convert` prints "relies on known divergence …"), and any other notes.
+function conversionNotes(translate) {
+ const notes = [...(translate.notes ?? [])].map((note) => escape(note));
+ for (const statement of translate.statements ?? [])
+ for (const d of statement.divergences ?? []) {
+ const at = d.constructs.map((construct) => `${escape(construct)}`).join(', ');
+ notes.push(`Relies on known divergence ${escape(d.id)} at ${at}${d.reason ? `: ${escape(d.reason)}` : ''}`);
+ }
+ return [...new Set(notes)].map((note) => `Note. ${note}
`).join(''); +} + +// A relation the schema does not declare: SQLQuack needs its columns and Snowflake types, and +// does not guess them. Each one gets a line saying so, with a button that adds a stub to fill in. +const UNKNOWN_RELATION = /^relation `(.+)` has no known columns$/; +const STUB_COLUMN = ['COLUMN_NAME', 'SNOWFLAKE_TYPE']; + +function declaredRelations() { + try { + return Object.keys(JSON.parse(schemaBox.value)); + } catch { + return []; + } +} + +function unknownRelationHints(diagnostics) { + const relations = new Set(); + for (const d of diagnostics ?? []) { + const match = d.code === 'SQ0004' && UNKNOWN_RELATION.exec(d.label ?? ''); + if (match) relations.add(match[1]); + } + const declared = declaredRelations(); + return [...relations] + .map((name) => { + const code = `${escape(name)}`;
+ return declared.includes(name)
+ ? `SQLQuack needs each table's columns and Snowflake types. Fill in ${code}'s in the Schema box.
` + : `SQLQuack needs each table's columns and Snowflake types. Add ${code} to the Schema box.` + + `
`; + }) + .join(''); +} + +// Adds `name` with one placeholder column to the end of the schema's JSON, keeping the rest of the +// text as typed, and selects the placeholder so typing replaces it. +function addRelation(name) { + const text = schemaBox.value; + const close = text.lastIndexOf('}'); + if (close < 0 || declaredRelations().includes(name)) return; + const before = text.slice(0, close).trimEnd(); + const column = `[${STUB_COLUMN.map((part) => JSON.stringify(part)).join(', ')}]`; + const entry = ` ${JSON.stringify(name)}: [\n ${column}\n ]`; + const separator = before.endsWith('{') ? '\n' : ',\n'; + schemaBox.value = `${before}${separator}${entry}\n${text.slice(close)}`; + schemaBox.closest('details').open = true; + const placeholder = `${before}${separator} ${JSON.stringify(name)}: [\n ["`.length; + schemaBox.focus(); + schemaBox.setSelectionRange(placeholder, placeholder + STUB_COLUMN[0].length); + schedule(); +} + // DuckDB-WASM, downloaded in the background once the page is idle (or on the first run). let duckdb = null; let duckdbLoad = null; @@ -329,6 +391,7 @@ const schedule = () => { document.addEventListener('click', (event) => { if (event.target.id === 'pg-run') execute(); + if (event.target.dataset.addRelation) addRelation(event.target.dataset.addRelation); }); sqlBox.addEventListener('input', () => { showCaption(null); diff --git a/website/public/styles.css b/website/public/styles.css index 2bd7b4d25..6a5d72408 100644 --- a/website/public/styles.css +++ b/website/public/styles.css @@ -1359,6 +1359,33 @@ footer a { display: none; } +.pg-hint code { + display: inline; +} + +.pg-conversion-note { + margin: 10px 0 0; + padding: 8px 10px; + border-left: 2px solid var(--primary); + background: var(--accent-soft); + color: var(--muted-foreground); + font-size: 13px; +} + +.pg-conversion-note code { + display: inline; +} + +.pg-hint { + display: flex; + flex-wrap: wrap; + align-items: center; + gap: 8px 12px; + margin: 0 0 10px; + color: var(--foreground); + font-size: 13px; +} + .terminal .warn { color: var(--warning); } diff --git a/website/tests/playground.test.mjs b/website/tests/playground.test.mjs index e3886e8d8..80857f154 100644 --- a/website/tests/playground.test.mjs +++ b/website/tests/playground.test.mjs @@ -117,3 +117,36 @@ test('translated SQL is laid out one clause per line unless the compact setting assert.equal(compact, laidOut.replace(/\n */g, ' ')); assert.ok(!compact.includes('\n')); }); + +test('an undeclared relation is refused by name, and the stub the page adds stays refused until filled in', async () => { + const { SCHEMA: PAGE_SCHEMA } = await import('../public/playground/examples.js'); + // The page reads the relation's name from this label to offer "Add T to schema". + const unknown = JSON.parse(analyze('SELECT * FROM t', PAGE_SCHEMA)).translate; + assert.equal(unknown.status, 'fail'); + assert.deepEqual( + unknown.diagnostics.map((d) => [d.code, d.label]), + [['SQ0004', 'relation `T` has no known columns']], + ); + // The stub's placeholder type is not a Snowflake type: no column is assumed, so it still refuses. + const stub = JSON.stringify({ ...JSON.parse(PAGE_SCHEMA), T: [['COLUMN_NAME', 'SNOWFLAKE_TYPE']] }); + assert.deepEqual(JSON.parse(analyze('SELECT * FROM t', stub)).translate.diagnostics.map((d) => d.code), ['SQ0004']); + // Every relation of the sample schema without semi-structured columns translates as declared. + for (const relation of ['ORDERS', 'CUSTOMERS', 'PRODUCTS', 'ORDER_ITEMS']) { + assert.equal(JSON.parse(analyze(`SELECT * FROM ${relation.toLowerCase()}`, PAGE_SCHEMA)).translate.status, 'pass', relation); + } +}); + +test('each known divergence a translation relies on is reported with its constructs and the policy reason', () => { + const repository = readFileSync(new URL('../../sqlquack.toml', import.meta.url), 'utf8'); + const policy = repository.replace('constructs = ["fn:HASH"]\ndefault = "refuse"', 'constructs = ["fn:HASH"]\ndefault = "warn"'); + assert.notEqual(policy, repository); + const translate = (settings) => JSON.parse(analyze('SELECT HASH(order_id) AS h FROM orders', SCHEMA, JSON.stringify(settings))).translate; + const [statement] = translate({ policy }).statements; + assert.deepEqual( + statement.divergences.map((d) => [d.id, d.constructs]), + [['hash', ['fn:HASH']]], + ); + assert.match(statement.divergences[0].reason, /never Snowflake's value/); + // Without a divergence, none is reported. + assert.deepEqual(JSON.parse(analyze('SELECT order_id FROM orders', SCHEMA)).translate.statements[0].divergences, []); +}); diff --git a/website/wasm/src/lib.rs b/website/wasm/src/lib.rs index f6ee9c655..d115b6208 100644 --- a/website/wasm/src/lib.rs +++ b/website/wasm/src/lib.rs @@ -322,6 +322,13 @@ fn report(sql: &str, schema: &str, settings: &str) -> Value { "name": column.name, "type": column.data_type.to_string(), })).collect::Snowflake raises this error for these rows, and so does the translated SQL in DuckDB.
', + version, + 'error', + ); } } diff --git a/website/public/playground/worker.js b/website/public/playground/worker.js index 2c9814284..86b8bda0f 100644 --- a/website/public/playground/worker.js +++ b/website/public/playground/worker.js @@ -16,8 +16,9 @@ self.onmessage = async ({ data }) => { ready.then(() => self.postMessage({ ready: true })); return; } - const { analyze, fixture_tables } = await ready; + const { analyze, fixture_tables, run_failure } = await ready; const started = performance.now(); - const result = data.op === 'fixture' ? fixture_tables(data.schema) : analyze(data.sql, data.schema, data.settings); + const result = + data.op === 'fixture' ? fixture_tables(data.schema) : data.op === 'failure' ? run_failure(data.message) : analyze(data.sql, data.schema, data.settings); self.postMessage({ id: data.id, result, elapsed: performance.now() - started }); }; diff --git a/website/tests/playground.test.mjs b/website/tests/playground.test.mjs index 80857f154..765bdc9ce 100644 --- a/website/tests/playground.test.mjs +++ b/website/tests/playground.test.mjs @@ -4,7 +4,7 @@ import assert from 'node:assert/strict'; import { readFileSync } from 'node:fs'; import { test } from 'node:test'; -import { initSync, analyze } from '../wasm/pkg/sqlquack_wasm.js'; +import { initSync, analyze, run_failure } from '../wasm/pkg/sqlquack_wasm.js'; import { rendered, underlined } from '../public/playground/spans.js'; initSync({ module: readFileSync(new URL('../wasm/pkg/sqlquack_wasm_bg.wasm', import.meta.url)) }); @@ -150,3 +150,17 @@ test('each known divergence a translation relies on is reported with its constru // Without a divergence, none is reported. assert.deepEqual(JSON.parse(analyze('SELECT order_id FROM orders', SCHEMA)).translate.statements[0].divergences, []); }); + +test('a run error a building block raised reads back as the Snowflake error, at the expression that raised it', () => { + const sql = 'SELECT CAST(note AS NUMBER(10,2)) AS v FROM orders'; + const [statement] = JSON.parse(analyze(sql, SCHEMA)).translate.statements; + const tag = /sqlquack:100038#[0-9a-f]{12}: [^']*/.exec(statement.sql)[0]; + // As DuckDB reports a failed cast of the raised text. + const failure = JSON.parse(run_failure(`Conversion Error: Could not convert string '${tag}' to INT32\n\nLINE 1: ...`)); + assert.equal(failure.errno, 100038); + assert.equal(failure.message, 'Numeric value is not recognized'); + const [location] = statement.raises[failure.raise_id]; + assert.equal(Array.from(sql).slice(location.start, location.end).join(''), 'CAST(note AS NUMBER(10,2))'); + // DuckDB's own errors are not read as Snowflake's. + assert.deepEqual(JSON.parse(run_failure('Binder Error: Referenced column "x" not found')), {}); +}); diff --git a/website/wasm/src/lib.rs b/website/wasm/src/lib.rs index d115b6208..31b93d720 100644 --- a/website/wasm/src/lib.rs +++ b/website/wasm/src/lib.rs @@ -12,6 +12,9 @@ use sqlquack_core::classification::main::classify::classify; use sqlquack_core::diagnostics::constants::SESSION_PARAMETERS; use sqlquack_core::diagnostics::main::diagnose::diagnose; use sqlquack_core::diagnostics::main::unplaced_diagnostic::unplaced_diagnostic; +use sqlquack_core::failures::constants::{ERROR_TAG_PREFIX, TAG_END}; +use sqlquack_core::failures::main::duckdb_failure::duckdb_failure; +use sqlquack_core::failures::main::raise_id::raise_id; use sqlquack_core::parsing::main::node_location::node_location; use sqlquack_core::parsing::main::parse_source::parse_source; use sqlquack_core::parsing::models::{SourceDialect, SourceLines}; @@ -50,6 +53,30 @@ pub fn analyze(sql: &str, schema: &str, settings: Option${escape(construct)}`).join(', ');
- notes.push(`Relies on known divergence ${escape(d.id)} at ${at}${d.reason ? `: ${escape(d.reason)}` : ''}`);
+ const kind = d.assumption ? 'assumption' : 'known divergence';
+ notes.push(`Relies on ${kind} ${escape(d.id)} at ${at}${d.reason ? `: ${escape(d.reason)}` : ''}`);
}
return [...new Set(notes)].map((note) => `Note. ${note}
`).join(''); } diff --git a/website/tests/playground.test.mjs b/website/tests/playground.test.mjs index 765bdc9ce..890f93e61 100644 --- a/website/tests/playground.test.mjs +++ b/website/tests/playground.test.mjs @@ -147,6 +147,12 @@ test('each known divergence a translation relies on is reported with its constru [['hash', ['fn:HASH']]], ); assert.match(statement.divergences[0].reason, /never Snowflake's value/); + assert.equal(statement.divergences[0].assumption, false); + // An assumption gives a wrong value silently where it does not hold, so it is reported as one. + const today = JSON.parse(analyze('SELECT CURRENT_DATE AS d', SCHEMA, JSON.stringify({ policy: repository, utc_session: true }))); + const assumed = today.translate.statements[0].divergences.find((d) => d.id === 'session_timezone_utc'); + assert.equal(assumed?.assumption, true); + assert.ok(assumed.reason); // Without a divergence, none is reported. assert.deepEqual(JSON.parse(analyze('SELECT order_id FROM orders', SCHEMA)).translate.statements[0].divergences, []); }); diff --git a/website/wasm/src/lib.rs b/website/wasm/src/lib.rs index 31b93d720..2484c1bd6 100644 --- a/website/wasm/src/lib.rs +++ b/website/wasm/src/lib.rs @@ -350,12 +350,20 @@ fn report(sql: &str, schema: &str, settings: &str) -> Value { "type": column.data_type.to_string(), })).collect::