@rebasepro/studio 0.23.0 → 0.24.0

package/dist/{SQLEditor-TBw_K6CW.js → SQLEditor-1An7w0j6.js}

@@ -1,11 +1,11 @@
 import { t as MonacoEditor } from "./MonacoEditor-CUxy5_k5.js";
 import { ConfirmationDialog, ErrorView, IconForView, useRebaseContext, useSnackbarController, useStudioCollectionRegistry, useStudioSidePanelController, useTranslation } from "@rebasepro/app";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { Button, Checkbox, CircularProgress, Collapse, CopyIcon, DatabaseIcon, Dialog, DialogActions, DialogContent, DialogTitle, IconButton, Menu, MenuIcon, MenuItem, MoreVerticalIcon, PencilIcon, PlayIcon, PlusIcon, RefreshCwIcon, ResizablePanels, Tab, Tabs, TerminalIcon, TextField, TextareaAutosize, Tooltip, Trash2Icon, Typography, VirtualTable, XIcon, cls, defaultBorderMixin, iconSize } from "@rebasepro/ui";
+import { Alert, Button, Checkbox, CircularProgress, Collapse, CopyIcon, DatabaseIcon, Dialog, DialogActions, DialogContent, DialogTitle, IconButton, Menu, MenuIcon, MenuItem, MoreVerticalIcon, PencilIcon, PlayIcon, PlusIcon, RefreshCwIcon, ResizablePanels, Tab, Tabs, TerminalIcon, TextField, TextareaAutosize, Tooltip, Trash2Icon, Typography, VirtualTable, XIcon, cls, defaultBorderMixin, iconSize, isKeyHandled } from "@rebasepro/ui";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { isArrayValue, isRecordValue, readStoredJson, readStoredString, toSnakeCase, writeStoredJson, writeStoredString } from "@rebasepro/utils";
 import { createPortal } from "react-dom";
-import { parse, parseFirst } from "pgsql-ast-parser";
+import { astVisitor, parse } from "pgsql-ast-parser";
 //#region src/components/SQLEditor/SchemaBrowser.tsx
 var SchemaBrowser = ({ onTableClick, schemas, isSchemaLoading, schemaError, onRetrySchema }) => {
 	const [expandedSchemas, setExpandedSchemas] = useState({ public: true });
@@ -470,242 +470,255 @@ function needsDestructiveConfirmation(sqlText) {
 	return statements.some(isDestructiveStatement);
 }
 /**
-* A table as SQL: `"schema"."table"` when the query named its schema, and a
-* bare `"table"` when it left it to the search path — which then resolves it
-* the same way it resolved the query.
+* A table as SQL: `"schema"."table"` when a schema is given, a bare `"table"`
+* otherwise.
 */
 function quoteTableName(tableName, schemaName) {
-	const quote = (identifier) => `"${identifier.replace(/"/g, "\"\"")}"`;
-	return schemaName ? `${quote(schemaName)}.${quote(tableName)}` : quote(tableName);
+	return schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
 }
-/**
-* The introspected columns of a table the query named — in the schema it
-* named, when it named one. Unqualified, the first schema that has a table of
-* that name answers.
-*/
-function findTableInfo(schemas, table) {
-	if (table.schema) return schemas[table.schema]?.find((t) => t.tableName === table.name);
-	for (const schema of Object.values(schemas)) {
-		const tableInfo = schema.find((t) => t.tableName === table.name);
-		if (tableInfo) return tableInfo;
-	}
+/** An identifier as SQL, whatever it holds: double-quoted, with `"` doubled. */
+function quoteIdentifier(identifier) {
+	return `"${identifier.replace(/"/g, "\"\"")}"`;
 }
+var refuse = (key, params = {}) => ({ refusal: {
+	key,
+	params
+} });
 /**
-* The name Postgres gives the result column of an unaliased select item, as
-* far as it can be told from the expression: a column keeps its name, a cast
-* the name of what it casts, a function call the function's, and anything
-* else a name no table column has.
-*/
-function expressionColumnName(expr) {
-	switch (expr.type) {
-		case "ref": return expr.name;
-		case "cast": {
-			const operandName = expressionColumnName(expr.operand);
-			if (operandName !== "?column?") return operandName;
-			return expr.to.kind === "array" ? operandName : expr.to.name;
-		}
-		case "call": return expr.function.name;
-		case "keyword": return expr.keyword;
-		case "case": return "case";
-		case "array select": return "array";
-		case "select": {
-			const [first] = expr.columns ?? [];
-			return first ? selectedColumnName(first) : "?column?";
-		}
-		default: return "?column?";
-	}
-}
-function selectedColumnName(column) {
-	return column.alias?.name ?? expressionColumnName(column.expr);
-}
-/**
-* How many columns of the query's result may carry `name` — an upper bound:
-* a `*` over a source whose columns are not known counts once for every name.
+* Which stored cell an edit of the result column `resultColumn` writes, and
+* how its row is found again — or why no edit is safe.
 *
-* A result row is an object keyed by column name, so where two columns share
-* a name the row holds only the last of them. A key or a value read from such
-* a row cannot be told apart from its namesake: for `SELECT * FROM posts p
-* JOIN authors a …` the row's `id` is the author's.
+* Decided on what the database reported, not on the query's text. Each
+* column of the result says which table column it was read from, or that it
+* was computed; a cell is editable only when it was read from a column of a
+* table, every column of that table's primary key was read too, and each of
+* them is the only column of the result with its name — a row holds one value
+* per name.
+*
+* The text was the only evidence before, and it was wrong twice over. For
+* `SELECT p.id, a.name FROM posts p JOIN authors a …` it took the post's `id`
+* for the author's key and updated whichever author shared the post's id.
+* For `SELECT id, lower(email) AS name FROM users` it wrote the edited text
+* to `users.name`.
+*
+* The database reports a table, not which mention of it: in a self-join both
+* sides are `authors`, and a key from one with a value from the other finds
+* the wrong row. So the query is still read, for one thing — the table must
+* be read once, and nothing it is read through may be read twice.
 */
-function resultColumnCounter(ast, schemas) {
-	const sources = (ast.from ?? []).map((item) => {
-		if (item.type === "table") {
-			const renamed = item.name.columnNames ?? [];
-			const columns = findTableInfo(schemas, {
-				name: item.name.name,
-				schema: item.name.schema
-			})?.columns.map((c, i) => renamed[i]?.name ?? c.name);
-			return {
-				refName: item.name.alias ?? item.name.name,
-				columns
-			};
-		}
-		if (item.type === "statement") {
-			const { statement } = item;
-			const named = statement.type === "select" && (statement.columns ?? []).every((c) => !(c.expr.type === "ref" && c.expr.name === "*"));
-			const renamed = item.columnNames ?? [];
-			const columns = named && statement.type === "select" ? (statement.columns ?? []).map((c, i) => renamed[i]?.name ?? selectedColumnName(c)) : void 0;
-			return {
-				refName: item.alias,
-				columns
-			};
-		}
-		return {
-			refName: item.alias?.name,
-			columns: void 0
-		};
+function resolveCellEdit(sqlText, provenance, resultColumn) {
+	const sameName = provenance.columns.filter((column) => column.name === resultColumn);
+	if (sameName.length !== 1) return refuse("studio_sql_edit_duplicate_column", { column: resultColumn });
+	const source = sameName[0].source;
+	if (!source) return refuse("studio_sql_edit_computed_column", { column: resultColumn });
+	const tableLabel = `${source.schema}.${source.table}`;
+	const table = provenance.tables.find((t) => t.schema === source.schema && t.table === source.table);
+	if (!table || table.kind !== "table" && table.kind !== "partitioned table") return refuse("studio_sql_edit_not_a_table", {
+		column: resultColumn,
+		table: tableLabel
 	});
-	return (name) => {
-		let count = 0;
-		for (const column of ast.columns ?? []) {
-			const expr = column.expr;
-			if (expr.type === "ref" && expr.name === "*") {
-				const covered = expr.table ? sources.filter((source) => source.refName === expr.table?.name) : sources;
-				if (covered.length === 0) count += 1;
-				for (const source of covered) count += source.columns ? source.columns.filter((c) => c === name).length : 1;
-			} else if (selectedColumnName(column) === name) count += 1;
-		}
-		return count;
-	};
+	if (table.hasInheritors) return refuse("studio_sql_edit_inherited_table", { table: tableLabel });
+	if (table.primaryKey.length === 0) return refuse("studio_sql_edit_no_primary_key", { table: tableLabel });
+	const key = [];
+	for (const keyColumn of table.primaryKey) {
+		const holders = provenance.columns.filter((column) => column.source?.schema === source.schema && column.source.table === source.table && column.source.column === keyColumn);
+		const holder = holders.length === 1 && provenance.columns.filter((column) => column.name === holders[0].name).length === 1 ? holders[0] : void 0;
+		if (!holder) return refuse("studio_sql_edit_key_missing", {
+			table: tableLabel,
+			columns: table.primaryKey.join(", ")
+		});
+		key.push({
+			column: keyColumn,
+			resultColumn: holder.name
+		});
+	}
+	const readOnce = tableReadOnce(sqlText, source.table);
+	if (readOnce !== true) return readOnce;
+	return { target: {
+		schema: source.schema,
+		table: source.table,
+		column: source.column,
+		key
+	} };
 }
 /**
-* Extract all tables referenced in a SQL query's FROM and JOIN clauses.
-* Returns an empty array for non-SELECT queries or parse failures.
+* Whether `sqlText` is one SELECT that reads `table` once — counting every
+* mention of a table of that name, in any schema and at any depth, and every
+* mention of a `WITH` query, since one read twice reads its tables twice.
 */
-function extractTablesFromQuery(sqlString) {
-	try {
-		const ast = parseFirst(sqlString);
-		if (ast.type !== "select") return [];
-		const tables = [];
-		const processFrom = (fromItems) => {
-			for (const item of fromItems) {
-				if (item.type === "table" && item.name) tables.push({
-					name: item.name.name,
-					schema: item.name.schema,
-					alias: item.name.alias
-				});
-				if (item.type === "join") {
-					if (item.left) processFrom([item.left]);
-					if (item.right) processFrom([item.right]);
-				}
-			}
-		};
-		if (ast.from) processFrom(ast.from);
-		return tables;
-	} catch {
-		return [];
-	}
+function tableReadOnce(sqlText, table) {
+	const statements = parseStatements(sqlText);
+	if (!statements) return refuse("studio_sql_edit_unreadable_query");
+	if (statements.length !== 1) return refuse("studio_sql_edit_not_a_select");
+	const [statement] = statements;
+	if (!(statement.type === "select" || statement.type === "with" && statement.in.type === "select" && statement.bind.every((binding) => binding.statement.type === "select"))) return refuse("studio_sql_edit_not_a_select");
+	const mentions = /* @__PURE__ */ new Map();
+	const withNames = [];
+	astVisitor((visitor) => ({
+		fromTable: (from) => {
+			const name = from.name.name.toLowerCase();
+			mentions.set(name, (mentions.get(name) ?? 0) + 1);
+			visitor.super().fromTable(from);
+		},
+		with: (withStatement) => {
+			withNames.push(...withStatement.bind.map((binding) => binding.alias.name.toLowerCase()));
+			visitor.super().with(withStatement);
+		}
+	})).statement(statement);
+	return (mentions.get(table.toLowerCase()) ?? 0) !== 1 || withNames.some((name) => (mentions.get(name) ?? 0) > 1) ? refuse("studio_sql_edit_table_read_twice", { table }) : true;
 }
 /**
-* Resolve which collections are referenced by a SQL query.
-*
-* Parses the SQL, extracts table names, and matches each against
-* registered collections via `collection.table` (falling back to
-* snake_case of `collection.slug`).
+* The collections a result's rows can be opened as: those whose table one of
+* the result's columns was read from, with the table's (single-column) primary
+* key read too, under a name no other column of the result has.
 *
-* For each matched collection, determines which result columns
-* belong to that table using the database schema information.
+* Matched on the provenance the database reported. A text match took the
+* result's `id` for every table of a join: `SELECT p.id, a.name FROM posts p
+* JOIN authors a …` offered to open the author whose id was the post's.
 */
-function resolveQueryCollections(sqlString, schemas, collections, resultColumns) {
-	const tables = extractTablesFromQuery(sqlString);
-	if (tables.length === 0) return [];
-	const selectColumns = [];
-	let countResultColumns;
-	try {
-		const ast = parseFirst(sqlString);
-		if (ast.type === "select") {
-			countResultColumns = resultColumnCounter(ast, schemas);
-			for (const col of ast.columns ?? []) if (col.expr?.type === "ref") selectColumns.push({
-				table: col.expr.table?.name,
-				column: col.expr.name,
-				alias: col.alias?.name
-			});
-		}
-	} catch {}
+function resolveQueryCollections(provenance, collections) {
 	const results = [];
-	for (const table of tables) {
-		const matched = collections.find((c) => {
+	for (const table of provenance.tables) {
+		const collection = collections.find((c) => {
 			const tableName = ("table" in c ? c.table : void 0) || toSnakeCase(c.slug);
 			const schemaName = ("schema" in c ? c.schema : void 0) || "public";
-			return tableName === table.name && (!table.schema || table.schema === schemaName);
+			return tableName === table.table && schemaName === table.schema;
 		});
-		if (!matched) continue;
-		const tableColumns = findTableInfo(schemas, table)?.columns.map((c) => c.name) ?? [];
-		let pkColumn;
-		const tableRef = table.alias || table.name;
-		const idSelectCol = selectColumns.find((sc) => sc.column === "id" && (!sc.table || sc.table === tableRef || sc.table === table.name));
-		if (idSelectCol) pkColumn = idSelectCol.alias || idSelectCol.column;
-		if (!pkColumn && resultColumns) {
-			if (resultColumns.includes("id")) pkColumn = "id";
-		}
-		if (!pkColumn && tableColumns.includes("id")) pkColumn = "id";
-		if (pkColumn && (!countResultColumns || countResultColumns(pkColumn) > 1)) pkColumn = void 0;
+		if (!collection || table.primaryKey.length !== 1) continue;
+		const [keyColumn] = table.primaryKey;
+		const holders = provenance.columns.filter((column) => column.source?.schema === table.schema && column.source.table === table.table && column.source.column === keyColumn);
+		if (holders.length !== 1) continue;
+		const pkColumn = holders[0].name;
+		if (provenance.columns.filter((column) => column.name === pkColumn).length !== 1) continue;
 		results.push({
-			tableName: table.name,
-			tableAlias: table.alias,
-			collection: matched,
-			columns: tableColumns,
+			tableName: table.table,
+			schemaName: table.schema,
+			collection,
 			pkColumn
 		});
 	}
 	return results;
 }
-function determineTableAndPK(sqlString, columnKey, schemas) {
-	try {
-		const tables = extractTablesFromQuery(sqlString);
-		const ast = parseFirst(sqlString);
-		if (ast.type !== "select") return { error: "Inline editing is only supported for SELECT queries." };
-		if (tables.length === 0) return { error: "Could not find any tables in the query." };
-		const selectColumns = [];
-		if (ast.columns) {
-			for (const col of ast.columns) if (col.expr?.type === "ref") selectColumns.push({
-				table: col.expr.table?.name,
-				column: col.expr.name,
-				alias: col.alias?.name
-			});
+/** A character an unquoted identifier or keyword can hold, `$` included. */
+var IDENTIFIER_CHARACTER = /[A-Za-z0-9_$]/;
+/**
+* Cut `sqlText` into code and the things in it whose text is data.
+*
+* A lexer, not a parser: it reads text the parser refuses as well, which is
+* most of what a person types while writing a query.
+*/
+function splitSql(sqlText) {
+	const segments = [];
+	let code = "";
+	const push = (text, kind) => {
+		if (code) segments.push({
+			text: code,
+			kind: "code"
+		});
+		code = "";
+		segments.push({
+			text,
+			kind
+		});
+	};
+	let i = 0;
+	while (i < sqlText.length) {
+		const ch = sqlText[i];
+		const next = sqlText[i + 1];
+		if (ch === "-" && next === "-") {
+			const newline = sqlText.indexOf("\n", i);
+			const end = newline === -1 ? sqlText.length : newline + 1;
+			push(sqlText.slice(i, end), "line comment");
+			i = end;
+			continue;
 		}
-		const resolvedColumn = selectColumns.find((sc) => sc.alias === columnKey || !sc.alias && sc.column === columnKey);
-		const actualDbColumnName = resolvedColumn?.column ?? columnKey;
-		const columnTableRef = resolvedColumn?.table;
-		let resolvedTable = null;
-		if (tables.length === 1) resolvedTable = tables[0];
-		else {
-			if (columnTableRef) {
-				const matchedTable = tables.find((t) => t.alias === columnTableRef || t.name === columnTableRef);
-				if (matchedTable) resolvedTable = matchedTable;
-			}
-			if (!resolvedTable) {
-				const matchedTables = tables.filter((t) => findTableInfo(schemas, t)?.columns.some((c) => c.name === actualDbColumnName) ?? false);
-				if (matchedTables.length === 1) resolvedTable = matchedTables[0];
-				else if (matchedTables.length > 1) return { error: `Ambiguous column "${columnKey}": Found in multiple queried tables.` };
-				else return { error: `Could not find column "${columnKey}" in the queried tables.` };
+		if (ch === "/" && next === "*") {
+			let depth = 1;
+			let j = i + 2;
+			while (j < sqlText.length && depth > 0) if (sqlText[j] === "/" && sqlText[j + 1] === "*") {
+				depth++;
+				j += 2;
+			} else if (sqlText[j] === "*" && sqlText[j + 1] === "/") {
+				depth--;
+				j += 2;
+			} else j++;
+			push(sqlText.slice(i, j), "block comment");
+			i = j;
+			continue;
+		}
+		if (ch === "'" || ch === "\"") {
+			const backslashEscapes = ch === "'" && /(^|[^A-Za-z0-9_$])[eE]$/.test(code);
+			let j = i + 1;
+			while (j < sqlText.length) if (backslashEscapes && sqlText[j] === "\\") j += 2;
+			else if (sqlText[j] === ch && sqlText[j + 1] === ch) j += 2;
+			else if (sqlText[j] === ch) {
+				j++;
+				break;
+			} else j++;
+			push(sqlText.slice(i, j), ch === "'" ? "literal" : "identifier");
+			i = j;
+			continue;
+		}
+		if (ch === "$" && !IDENTIFIER_CHARACTER.test(code.slice(-1))) {
+			const tag = /^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/.exec(sqlText.slice(i));
+			if (tag) {
+				const close = sqlText.indexOf(tag[0], i + tag[0].length);
+				const end = close === -1 ? sqlText.length : close + tag[0].length;
+				push(sqlText.slice(i, end), "literal");
+				i = end;
+				continue;
 			}
 		}
-		if (!resolvedTable) return { error: "Could not resolve the target table." };
-		const resolvedTableName = resolvedTable.name;
-		const pkDbColumns = (findTableInfo(schemas, resolvedTable)?.columns ?? []).filter((c) => c.isPrimaryKey).map((c) => c.name);
-		if (pkDbColumns.length === 0) return { error: `Table "${resolvedTableName}" has no primary key defined.` };
-		const tableAlias = resolvedTable.alias;
-		const primaryKeys = pkDbColumns.map((dbCol) => {
-			const selectCol = selectColumns.find((sc) => sc.column === dbCol && (!sc.table || sc.table === (tableAlias || resolvedTableName)));
-			return {
-				dbColumn: dbCol,
-				resultColumn: selectCol?.alias || selectCol?.column || dbCol
-			};
-		});
-		const countResultColumns = resultColumnCounter(ast, schemas);
-		if (countResultColumns(columnKey) > 1) return { error: `Ambiguous column "${columnKey}": the result has more than one column of that name. Give each one its own alias to edit it.` };
-		const sharedKey = primaryKeys.find((pk) => countResultColumns(pk.resultColumn) > 1);
-		if (sharedKey) return { error: `Cannot tell which "${sharedKey.resultColumn}" column is the key of "${resolvedTableName}": the result has more than one column of that name. Give it its own alias (${tableAlias || resolvedTableName}.${sharedKey.dbColumn} AS ${resolvedTableName}_${sharedKey.dbColumn}) to edit this table.` };
-		return {
-			tableName: resolvedTableName,
-			schemaName: resolvedTable.schema,
-			primaryKeys
-		};
-	} catch (e) {
-		console.warn("Failed to parse SQL AST:", e);
-		return { error: `Could not safely parse query for inline editing: ${e instanceof Error ? e.message : String(e)}` };
+		code += ch;
+		i++;
 	}
+	if (code) segments.push({
+		text: code,
+		kind: "code"
+	});
+	return segments;
+}
+/**
+* The console's "Format SQL": runs of whitespace become one space, a comma is
+* followed by one, and an `=` standing alone gets one on each side — in the
+* code only.
+*
+* A literal, a quoted identifier and a comment are copied as they are: their
+* text is data, and rewriting `'a,b'` to `'a, b'` changes the value the next
+* Run writes. A line comment keeps the line break that ends it, or it would
+* swallow the code after it. `>=`, `<=`, `!=`, `:=` and `=>` are operators of
+* their own and are left whole.
+*/
+function formatSql(sqlText) {
+	const segments = splitSql(sqlText);
+	return segments.map((segment, index) => {
+		if (segment.kind !== "code") return segment.text;
+		const tidied = segment.text.replace(/\s+/g, " ").replace(/\s*,\s*/g, ", ").replace(/(?<![<>!:=~*+\-/%^&|#@?])\s*=\s*(?![=>~*<])/g, " = ");
+		return segments[index - 1]?.kind === "line comment" ? tidied.trimStart() : tidied;
+	}).join("").trim();
+}
+/**
+* `sqlText` with the console's automatic `LIMIT` on it, or `null` when it
+* takes none (see {@link acceptsAutoLimit}).
+*
+* The limit goes straight after the statement's last token — before a
+* trailing comment, which would otherwise swallow it, and in place of a
+* trailing `;`. A query that computes an aggregate is limited like any other:
+* the limit applies to the rows it returns, so a `count(*)` still counts every
+* row, and a window `count(*) OVER ()` is no longer a way past the cap.
+*/
+function withAutoLimit(sqlText, limit) {
+	if (!acceptsAutoLimit(sqlText)) return null;
+	const segments = splitSql(sqlText);
+	const isComment = (segment) => segment.kind === "line comment" || segment.kind === "block comment";
+	const isFiller = (segment) => isComment(segment) || segment.kind === "code" && /^[\s;]*$/.test(segment.text);
+	let last = segments.length - 1;
+	while (last >= 0 && isFiller(segments[last])) last--;
+	if (last < 0) return null;
+	const lastSegment = segments[last];
+	const head = lastSegment.kind === "code" ? lastSegment.text.replace(/[\s;]+$/, "") : lastSegment.text;
+	const tail = (lastSegment.kind === "code" ? lastSegment.text.slice(head.length) : "").replace(/;/g, "") + segments.slice(last + 1).map((segment) => segment.kind === "code" ? segment.text.replace(/;/g, "") : segment.text).join("");
+	return `${segments.slice(0, last).map((segment) => segment.text).join("")}${head} LIMIT ${limit};${tail.trimEnd()}`;
 }
 //#endregion
 //#region src/components/SQLEditor/ExplainVisualizer.tsx
@@ -911,13 +924,13 @@ var FixedEditorOverlay = ({ displayValue, onSave, onCancel }) => {
 					e.target.value = val;
 				},
 				onBlur: (e) => {
-					onSave(e.target.value || null);
+					onSave(e.target.value);
 					onCancel();
 				},
 				onKeyDown: (e) => {
 					if (e.key === "Enter" && !e.shiftKey) {
 						e.preventDefault();
-						onSave(e.currentTarget.value || null);
+						onSave(e.currentTarget.value);
 						onCancel();
 					}
 					if (e.key === "Escape") onCancel();
@@ -958,7 +971,18 @@ var SQLEditor = () => {
 		return readStoredString(`rebase_sql_selected_role_${client?.baseUrl ? client.baseUrl.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9]/g, "_") : "default"}`) || void 0;
 	});
 	const [availableDatabases, setAvailableDatabases] = useState([]);
+	/**
+	* The database the app reads and writes — the one the CMS opens a record
+	* on. Rows read anywhere else are not that record.
+	*/
+	const [appDatabase, setAppDatabase] = useState(void 0);
 	const [availableRoles, setAvailableRoles] = useState([]);
+	/**
+	* Who every statement runs as, once a run has shown that the server does
+	* not switch roles (`DISABLE_DB_ROLE_SWITCHING`): the role picker then
+	* changes nothing, and says so.
+	*/
+	const [connectionOwner, setConnectionOwner] = useState(null);
 	const [isLoadingConfig, setIsLoadingConfig] = useState(true);
 	const [connectionConfigError, setConnectionConfigError] = useState(null);
 	const [tabs, setTabs] = useState(() => {
@@ -973,7 +997,10 @@ var SQLEditor = () => {
 			error: null,
 			execTime: null,
 			lastExecutedSql: null,
-			lastExecutedConnection: null
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}));
 		if (restored.length > 0) return restored;
 		return [{
@@ -987,7 +1014,10 @@ var SQLEditor = () => {
 			error: null,
 			execTime: null,
 			lastExecutedSql: null,
-			lastExecutedConnection: null
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}];
 	});
 	const [activeTabId, setActiveTabId] = useState(() => {
@@ -1024,6 +1054,7 @@ var SQLEditor = () => {
 				if (mounted) {
 					setAvailableDatabases(dbs);
 					setAvailableRoles(roles);
+					setAppDatabase(currentDbFromApi);
 					const loadedDb = readStoredString(`rebase_sql_selected_db_${projectPrefix}`) || void 0;
 					const loadedRole = readStoredString(`rebase_sql_selected_role_${projectPrefix}`) || void 0;
 					const initialActiveTabId = readStoredString(`rebase_sql_active_tab_${projectPrefix}`) || "1";
@@ -1200,8 +1231,23 @@ var SQLEditor = () => {
 	const [autoLimit, setAutoLimit] = useState(true);
 	const [isConfirmDialogOpen, setIsConfirmDialogOpen] = useState(false);
 	const [pendingAction, setPendingAction] = useState(null);
+	/**
+	* The cell being edited, and the text its editor opened with — what
+	* closing the editor unchanged is compared against.
+	*/
 	const [editingCell, setEditingCell] = useState(null);
 	const isCurrentConnection = useCallback((connection) => connection !== null && connection.database === selectedDatabase && connection.role === selectedRole, [selectedDatabase, selectedRole]);
+	/**
+	* Which stored cell a result cell is — by what the database said about the
+	* last run's columns, and nothing else.
+	*/
+	const resolveEdit = useCallback((columnKey) => {
+		if (!activeTab.lastExecutedSql || !activeTab.lastProvenance) return { refusal: {
+			key: "studio_sql_edit_computed_column",
+			params: { column: columnKey }
+		} };
+		return resolveCellEdit(activeTab.lastExecutedSql, activeTab.lastProvenance, columnKey);
+	}, [activeTab.lastExecutedSql, activeTab.lastProvenance]);
 	const handleDoubleClick = useCallback((rowIndex, columnKey, initialValue, rowData) => {
 		if (!activeTab.lastExecutedSql) {
 			snackbarController.open({
@@ -1217,15 +1263,15 @@ var SQLEditor = () => {
 			});
 			return;
 		}
-		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
-		if (resolution.error || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
+		const resolution = resolveEdit(columnKey);
+		if (!resolution.target) {
 			snackbarController.open({
 				type: "error",
-				message: resolution.error || t("studio_sql_cannot_resolve_table")
+				message: t(resolution.refusal.key, resolution.refusal.params)
 			});
 			return;
 		}
-		const missingPKs = resolution.primaryKeys.filter((pk) => rowData[pk.resultColumn] === void 0 || rowData[pk.resultColumn] === null);
+		const missingPKs = resolution.target.key.filter((pk) => rowData[pk.resultColumn] === void 0 || rowData[pk.resultColumn] === null);
 		if (missingPKs.length > 0) {
 			snackbarController.open({
 				type: "error",
@@ -1242,14 +1288,15 @@ var SQLEditor = () => {
 		activeTab.lastExecutedSql,
 		activeTab.lastExecutedConnection,
 		isCurrentConnection,
-		schemas,
+		resolveEdit,
 		snackbarController,
 		t
 	]);
-	const handleCellSave = useCallback(async (newValue, rowData, columnKey, rowIndex) => {
+	const handleCellSave = useCallback(async (text, rowData, columnKey, rowIndex) => {
 		if (!editingCell || !activeTab.lastExecutedSql) return;
 		setEditingCell(null);
-		if (newValue === editingCell.initialValue) return;
+		if (text === editingCell.initialValue) return;
+		const newValue = text === "" ? null : text;
 		const connection = activeTab.lastExecutedConnection;
 		if (!isCurrentConnection(connection)) {
 			snackbarController.open({
@@ -1258,54 +1305,44 @@ var SQLEditor = () => {
 			});
 			return;
 		}
-		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
-		if (resolution.error || !resolution.tableName || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
+		const resolution = resolveEdit(columnKey);
+		if (!resolution.target) {
 			snackbarController.open({
 				type: "error",
-				message: resolution.error || "Resolution failed."
+				message: t(resolution.refusal.key, resolution.refusal.params)
 			});
 			return;
 		}
-		const tableName = quoteTableName(resolution.tableName, resolution.schemaName);
+		const target = resolution.target;
 		const formatValue = (val) => {
 			if (val === null || val === void 0) return "NULL";
 			if (typeof val === "number") return val;
 			if (typeof val === "boolean") return val ? "TRUE" : "FALSE";
 			return `'${String(val).replace(/'/g, "''")}'`;
 		};
-		const resolveDbColumnName = (resultColKey) => {
-			try {
-				const ast = parseFirst(activeTab.lastExecutedSql);
-				if (ast.type === "select" && ast.columns) {
-					for (const col of ast.columns) if (col.expr?.type === "ref") {
-						const alias = col.alias?.name;
-						const colName = col.expr.name;
-						if (alias === resultColKey || !alias && colName === resultColKey) return colName;
-					}
-				}
-			} catch {}
-			return resultColKey;
-		};
-		const dbColumnName = resolveDbColumnName(columnKey);
-		const whereConditions = resolution.primaryKeys.map((pk) => `"${pk.dbColumn}" = ${formatValue(rowData[pk.resultColumn])}`).join(" AND ");
-		const updateSql = `UPDATE ${tableName} SET "${dbColumnName}" = ${formatValue(newValue)} WHERE ${whereConditions};`;
+		const whereConditions = target.key.map((pk) => `${quoteIdentifier(pk.column)} = ${formatValue(rowData[pk.resultColumn])}`).join(" AND ");
+		const updateSql = `UPDATE ${quoteTableName(target.table, target.schema)} SET ${quoteIdentifier(target.column)} = ${formatValue(newValue)} WHERE ${whereConditions};`;
 		try {
-			if (databaseAdmin?.executeSql) {
-				await databaseAdmin.executeSql(updateSql, {
-					database: connection.database,
-					role: connection.role
-				});
-				const newResults = [...activeTab.results || []];
-				if (newResults[rowIndex]) newResults[rowIndex] = {
-					...newResults[rowIndex],
-					[columnKey]: newValue
-				};
-				updateActiveTab({ results: newResults });
+			if (!(await databaseAdmin?.runSqlScript?.(updateSql, {
+				database: connection.database,
+				role: connection.role
+			}))?.rowCount) {
 				snackbarController.open({
-					type: "success",
-					message: t("studio_sql_row_updated")
+					type: "error",
+					message: t("studio_sql_update_no_row")
 				});
+				return;
 			}
+			const newResults = [...activeTab.results || []];
+			if (newResults[rowIndex]) newResults[rowIndex] = {
+				...newResults[rowIndex],
+				[columnKey]: newValue
+			};
+			updateActiveTab({ results: newResults });
+			snackbarController.open({
+				type: "success",
+				message: t("studio_sql_row_updated")
+			});
 		} catch (e) {
 			snackbarController.open({
 				type: "error",
@@ -1314,7 +1351,7 @@ var SQLEditor = () => {
 		}
 	}, [
 		editingCell,
-		schemas,
+		resolveEdit,
 		activeTab.lastExecutedSql,
 		activeTab.lastExecutedConnection,
 		activeTab.results,
@@ -1390,7 +1427,10 @@ var SQLEditor = () => {
 			error: null,
 			execTime: null,
 			lastExecutedSql: null,
-			lastExecutedConnection: null
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}]);
 		setActiveTabId(newId);
 	};
@@ -1419,8 +1459,7 @@ var SQLEditor = () => {
 		});
 	}, [activeTab.sql, projectPrefix]);
 	const handlePrettify = () => {
-		const formatted = activeTab.sql.replace(/\s+/g, " ").replace(/\s?,\s?/g, ", ").replace(/\s?=\s?/g, " = ").trim();
-		setSql(formatted);
+		setSql(formatSql(activeTab.sql));
 	};
 	/** The editor, for the selection the toolbar's buttons act on. */
 	const editorHandle = useRef(null);
@@ -1438,7 +1477,10 @@ var SQLEditor = () => {
 			error: null,
 			results: null,
 			lastExecutedSql: null,
-			lastExecutedConnection: null
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		});
 		const start = performance.now();
 		try {
@@ -1460,33 +1502,39 @@ var SQLEditor = () => {
 		}
 	};
 	const executeRun = useCallback(async (sqlOverride) => {
-		let sqlToRun = sqlOverride || activeTab.sql;
-		const isAggregate = /\b(COUNT|SUM|AVG|MIN|MAX)\s*\(/i.test(sqlToRun);
-		if (autoLimit && acceptsAutoLimit(sqlToRun) && !isAggregate) {
-			sqlToRun = sqlToRun.trim().replace(/;$/, "");
-			sqlToRun = `${sqlToRun} LIMIT 1000;`;
-		}
+		const written = sqlOverride || activeTab.sql;
+		const sqlToRun = (autoLimit ? withAutoLimit(written, 1e3) : null) ?? written;
 		updateActiveTab({
 			loading: true,
 			error: null,
-			results: null
+			results: null,
+			notices: []
 		});
 		const start = performance.now();
 		try {
-			if (databaseAdmin?.executeSql) {
-				const result = await databaseAdmin.executeSql(sqlToRun, {
+			if (databaseAdmin?.runSqlScript || databaseAdmin?.executeSql) {
+				const connection = {
 					database: selectedDatabase,
 					role: selectedRole
-				});
+				};
+				const run = databaseAdmin.runSqlScript ? await databaseAdmin.runSqlScript(sqlToRun, connection) : void 0;
+				const rows = run ? run.rows : await databaseAdmin.executeSql(sqlToRun, connection);
 				updateActiveTab({
-					results: result,
+					results: rows,
 					execTime: Math.round(performance.now() - start),
 					lastExecutedSql: sqlToRun,
-					lastExecutedConnection: {
-						database: selectedDatabase,
-						role: selectedRole
-					}
+					lastExecutedConnection: connection,
+					ranAs: run?.effectiveRole ?? null,
+					lastProvenance: run ? {
+						columns: run.columns,
+						tables: run.tables
+					} : {
+						columns: Object.keys(rows[0] ?? {}).map((name) => ({ name })),
+						tables: []
+					},
+					notices: run?.notices ?? []
 				});
+				if (run?.effectiveRole && connection.role) setConnectionOwner(run.effectiveRole !== connection.role ? run.effectiveRole : null);
 				if (history[history.length - 1] !== activeTab.sql) saveHistory([...history, activeTab.sql]);
 			} else updateActiveTab({ error: t("studio_sql_execution_not_supported") });
 		} catch (e) {
@@ -1516,6 +1564,7 @@ var SQLEditor = () => {
 	}, [activeTab.sql, executeRun]);
 	useEffect(() => {
 		const handleKeyDown = (e) => {
+			if (isKeyHandled(e)) return;
 			if ((e.metaKey || e.ctrlKey) && e.key === "Enter") {
 				const activeElement = document.activeElement;
 				const isInput = activeElement?.tagName === "INPUT" || activeElement?.tagName === "TEXTAREA";
@@ -1664,14 +1713,8 @@ var SQLEditor = () => {
 		});
 		const savedWidths = columnWidths[activeTab.sql] || {};
 		const resultColumnKeys = Object.keys(results[0]);
-		const actionableCollections = (() => {
-			if (!activeTab.lastExecutedSql || !collectionRegistry.collections) return [];
-			try {
-				return resolveQueryCollections(activeTab.lastExecutedSql, schemas, collectionRegistry.collections, resultColumnKeys);
-			} catch {
-				return [];
-			}
-		})().filter((mc) => mc.pkColumn && resultColumnKeys.includes(mc.pkColumn));
+		const readFromAppDatabase = activeTab.lastExecutedConnection !== null && (activeTab.lastExecutedConnection.database === void 0 || activeTab.lastExecutedConnection.database === appDatabase);
+		const actionableCollections = activeTab.lastProvenance && collectionRegistry.collections && readFromAppDatabase ? resolveQueryCollections(activeTab.lastProvenance, collectionRegistry.collections).filter((mc) => resultColumnKeys.includes(mc.pkColumn)) : [];
 		const getRowEntityActions = (rowData) => {
 			if (!rowData) return [];
 			return actionableCollections.filter((mc) => rowData[mc.pkColumn] != null).map((mc) => ({
@@ -1743,6 +1786,10 @@ var SQLEditor = () => {
 											}),
 											children: /* @__PURE__ */ jsx(IconButton, {
 												size: "small",
+												"aria-label": t("studio_sql_edit_entity", {
+													name: ra.collection.collection.name,
+													id: String(ra.entityId)
+												}),
 												className: "text-surface-400 dark:text-surface-500 hover:text-surface-600 dark:hover:text-surface-300 transition-colors",
 												onClick: (e) => {
 													e.stopPropagation();
@@ -1799,7 +1846,7 @@ var SQLEditor = () => {
 								children: /* @__PURE__ */ jsx("div", {
 									className: "truncate flex-grow",
 									title: displayValue,
-									children: displayValue === "" ? /* @__PURE__ */ jsx("span", {
+									children: value === null || value === void 0 ? /* @__PURE__ */ jsx("span", {
 										className: "text-text-disabled dark:text-text-disabled-dark italic text-[11px]",
 										children: "NULL"
 									}) : displayValue
@@ -1949,6 +1996,7 @@ var SQLEditor = () => {
 									children: /* @__PURE__ */ jsx(IconButton, {
 										size: "small",
 										onClick: handlePrettify,
+										"aria-label": t("studio_sql_format_sql"),
 										children: /* @__PURE__ */ jsx(MenuIcon, { size: iconSize.smallest })
 									})
 								}),
@@ -2029,7 +2077,7 @@ var SQLEditor = () => {
 											className: "mr-1.5 text-text-disabled dark:text-text-disabled-dark"
 										}), /* @__PURE__ */ jsx("span", {
 											className: "max-w-[160px] truncate",
-											children: isLoadingConfig ? "..." : `${selectedDatabase || t("studio_sql_select_db")}${selectedRole ? ` (${selectedRole})` : ""}`
+											children: isLoadingConfig ? "..." : `${selectedDatabase || t("studio_sql_select_db")}${connectionOwner ?? selectedRole ? ` (${connectionOwner ?? selectedRole})` : ""}`
 										})]
 									}),
 									children: /* @__PURE__ */ jsxs("div", {
@@ -2062,8 +2110,13 @@ var SQLEditor = () => {
 													children: t("studio_sql_role")
 												})
 											}),
+											connectionOwner && /* @__PURE__ */ jsx("div", {
+												className: "px-3 py-1.5 text-xs text-text-secondary dark:text-text-secondary-dark max-w-[240px] break-words",
+												children: t("studio_sql_role_switching_disabled", { role: connectionOwner })
+											}),
 											availableRoles.map((role) => /* @__PURE__ */ jsxs(MenuItem, {
 												dense: true,
+												disabled: connectionOwner !== null,
 												onClick: () => handleRoleChange(role),
 												className: cls("text-xs", selectedRole === role && "text-primary dark:text-primary-dark"),
 												children: [role, role === "postgres" ? " " + t("studio_sql_collections_label") : ""]
@@ -2103,17 +2156,39 @@ var SQLEditor = () => {
 						}),
 						secondPanel: /* @__PURE__ */ jsxs("div", {
 							className: "h-full w-full flex flex-col bg-surface-well overflow-hidden min-h-0",
-							children: [/* @__PURE__ */ jsx("div", {
-								className: cls("p-2 px-4 bg-surface-raised border-b shrink-0 flex items-center", defaultBorderMixin),
-								children: /* @__PURE__ */ jsx(Typography, {
-									variant: "caption",
-									className: "font-semibold text-text-disabled dark:text-text-disabled-dark uppercase tracking-widest text-[10px]",
-									children: t("studio_sql_query_results")
+							children: [
+								/* @__PURE__ */ jsx("div", {
+									className: cls("p-2 px-4 bg-surface-raised border-b shrink-0 flex items-center", defaultBorderMixin),
+									children: /* @__PURE__ */ jsx(Typography, {
+										variant: "caption",
+										className: "font-semibold text-text-disabled dark:text-text-disabled-dark uppercase tracking-widest text-[10px]",
+										children: t("studio_sql_query_results")
+									})
+								}),
+								!loading && results && activeTab.ranAs && activeTab.lastExecutedConnection?.role && activeTab.ranAs !== activeTab.lastExecutedConnection.role && /* @__PURE__ */ jsx("div", {
+									className: "px-4 pt-2 shrink-0",
+									children: /* @__PURE__ */ jsx(Alert, {
+										color: "warning",
+										size: "small",
+										children: t("studio_sql_ran_as_other_role", {
+											ranAs: activeTab.ranAs,
+											role: activeTab.lastExecutedConnection.role
+										})
+									})
+								}),
+								!loading && activeTab.notices.length > 0 && /* @__PURE__ */ jsx("div", {
+									className: "px-4 pt-2 flex flex-col gap-1 shrink-0",
+									children: activeTab.notices.map((notice, index) => /* @__PURE__ */ jsx(Alert, {
+										color: "warning",
+										size: "small",
+										children: `${notice.severity}: ${notice.message}`
+									}, index))
+								}),
+								/* @__PURE__ */ jsx("div", {
+									className: "flex-grow flex flex-col min-h-0 overflow-hidden",
+									children: renderResults()
 								})
-							}), /* @__PURE__ */ jsx("div", {
-								className: "flex-grow flex flex-col min-h-0 overflow-hidden",
-								children: renderResults()
-							})]
+							]
 						})
 					})]
 				})
@@ -2171,4 +2246,4 @@ var SQLEditor = () => {
 //#endregion
 export { SQLEditor };
 
-//# sourceMappingURL=SQLEditor-TBw_K6CW.js.map
+//# sourceMappingURL=SQLEditor-1An7w0j6.js.map