@rebasepro/studio 0.22.0 → 0.24.0

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

@@ -1,11 +1,11 @@
-import { t as MonacoEditor } from "./MonacoEditor-D0_QljcX.js";
+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 { 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 });
@@ -393,152 +393,332 @@ var SQLEditorSidebar = ({ onSelectSnippet, onTableClick, snippets, history, onDe
 };
 //#endregion
 //#region src/utils/sql_utils.ts
-/**
-* Extract all tables referenced in a SQL query's FROM and JOIN clauses.
-* Returns an empty array for non-SELECT queries or parse failures.
-*/
-function extractTablesFromQuery(sqlString) {
+/** The statements in `sqlText`, or `null` when the parser cannot read it. */
+function parseStatements(sqlText) {
 	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,
-					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;
+		return parse(sqlText);
 	} catch {
-		return [];
+		return null;
 	}
 }
 /**
-* Resolve which collections are referenced by a SQL query.
+* The `EXPLAIN` for one statement, or `null` when `sqlText` is not exactly one.
 *
-* Parses the SQL, extracts table names, and matches each against
-* registered collections via `collection.table` (falling back to
-* snake_case of `collection.slug`).
+* Never `ANALYZE`: that executes the statement to time it, so explaining a
+* `DELETE` deleted the rows — without the confirmation "Run" asks for.
 *
-* For each matched collection, determines which result columns
-* belong to that table using the database schema information.
+* And never more than one statement. Sent as one simple query, `EXPLAIN (…)
+* SELECT 1; DELETE …` explains the SELECT and *runs* the DELETE. Text the
+* parser cannot read is still explained, as long as no `;` could be hiding a
+* second statement in it.
 */
-function resolveQueryCollections(sqlString, schemas, collections, resultColumns) {
-	const tables = extractTablesFromQuery(sqlString);
-	if (tables.length === 0) return [];
-	const selectColumns = [];
-	try {
-		const ast = parseFirst(sqlString);
-		if (ast.type === "select" && 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
-			});
+function buildExplainSql(sqlText) {
+	const statement = sqlText.trim().replace(/;+$/, "").trim();
+	if (!statement) return null;
+	const statements = parseStatements(statement);
+	return (statements ? statements.length === 1 : !statement.includes(";")) ? `EXPLAIN (FORMAT JSON) ${statement}` : null;
+}
+/**
+* Whether the console's automatic `LIMIT` may be appended to `sqlText`: one
+* top-level SELECT that has no limit of its own.
+*
+* Decided on the parsed statement, not the text. A search for the word SELECT
+* also found it inside `INSERT INTO … SELECT` and `CREATE TABLE … AS SELECT`,
+* which then copied a thousand rows and reported success, and at the start of
+* a script whose last statement the appended `LIMIT` turned into a syntax
+* error. Text the parser cannot read is left as written.
+*/
+function acceptsAutoLimit(sqlText) {
+	const statements = parseStatements(sqlText);
+	if (!statements || statements.length !== 1) return false;
+	const [statement] = statements;
+	return statement.type === "select" && !statement.limit;
+}
+/** A destructive command named anywhere in a text, comments included. */
+var DESTRUCTIVE_COMMAND = /\b(DELETE|UPDATE|DROP|TRUNCATE)\b/i;
+function isDestructiveStatement(statement) {
+	switch (statement.type) {
+		case "delete":
+		case "update": return !statement.where;
+		case "truncate table":
+		case "drop table":
+		case "drop sequence":
+		case "drop index":
+		case "drop type":
+		case "drop trigger":
+		case "drop function": return true;
+		case "alter table": return statement.changes.some((change) => change.type === "drop column" || change.type === "drop constraint");
+		case "with": return statement.bind.some((binding) => isDestructiveStatement(binding.statement)) || isDestructiveStatement(statement.in);
+		case "with recursive": return isDestructiveStatement(statement.in);
+		case "do": return DESTRUCTIVE_COMMAND.test(statement.code);
+		default: return false;
+	}
+}
+/**
+* Whether "Run" asks before running `sqlText`: a statement in it deletes or
+* updates without a WHERE of its own, drops or truncates.
+*
+* Decided per parsed statement, not on the text. A search of the text for the
+* word WHERE found it in another statement or in a comment, so `DELETE FROM
+* posts; SELECT * FROM posts WHERE id = 1` deleted every post without asking.
+* Text the parser cannot read is confirmed whenever it names a destructive
+* command.
+*/
+function needsDestructiveConfirmation(sqlText) {
+	const statements = parseStatements(sqlText);
+	if (!statements) return DESTRUCTIVE_COMMAND.test(sqlText);
+	return statements.some(isDestructiveStatement);
+}
+/**
+* A table as SQL: `"schema"."table"` when a schema is given, a bare `"table"`
+* otherwise.
+*/
+function quoteTableName(tableName, schemaName) {
+	return schemaName ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(tableName)}` : quoteIdentifier(tableName);
+}
+/** 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
+} });
+/**
+* Which stored cell an edit of the result column `resultColumn` writes, and
+* how its row is found again — or why no edit is safe.
+*
+* 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 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
+	});
+	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
+	} };
+}
+/**
+* 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 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);
 		}
-	} catch {}
+	})).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;
+}
+/**
+* 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.
+*
+* 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(provenance, collections) {
 	const results = [];
-	for (const table of tables) {
-		const matched = collections.find((c) => {
-			return (("table" in c ? c.table : void 0) || toSnakeCase(c.slug)) === table.name;
+	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.table && schemaName === table.schema;
 		});
-		if (!matched) continue;
-		const tableColumns = [];
-		for (const schemaEntries of Object.values(schemas)) {
-			const tableInfo = schemaEntries.find((t) => t.tableName === table.name);
-			if (tableInfo) {
-				tableColumns.push(...tableInfo.columns.map((c) => c.name));
-				break;
-			}
-		}
-		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 (!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 resolvedTableName = null;
-		if (tables.length === 1) resolvedTableName = tables[0].name;
-		else {
-			if (columnTableRef) {
-				const matchedTable = tables.find((t) => t.alias === columnTableRef || t.name === columnTableRef);
-				if (matchedTable) resolvedTableName = matchedTable.name;
-			}
-			if (!resolvedTableName) {
-				const matchedTables = tables.filter((t) => {
-					for (const schema of Object.values(schemas)) {
-						const tableInfo = schema.find((ti) => ti.tableName === t.name);
-						if (tableInfo && tableInfo.columns.some((c) => c.name === actualDbColumnName)) return true;
-					}
-					return false;
-				});
-				if (matchedTables.length === 1) resolvedTableName = matchedTables[0].name;
-				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 (!resolvedTableName) return { error: "Could not resolve the target table." };
-		let pkDbColumns = [];
-		for (const schema of Object.values(schemas)) {
-			const tableInfo = schema.find((t) => t.tableName === resolvedTableName);
-			if (tableInfo) {
-				pkDbColumns = tableInfo.columns.filter((c) => c.isPrimaryKey).map((c) => c.name);
+		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 (pkDbColumns.length === 0) return { error: `Table "${resolvedTableName}" has no primary key defined.` };
-		const tableAlias = tables.find((t) => t.name === resolvedTableName)?.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
-			};
-		});
-		return {
-			tableName: resolvedTableName,
-			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
@@ -744,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();
@@ -791,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(() => {
@@ -805,7 +996,11 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}));
 		if (restored.length > 0) return restored;
 		return [{
@@ -818,7 +1013,11 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}];
 	});
 	const [activeTabId, setActiveTabId] = useState(() => {
@@ -855,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";
@@ -1031,7 +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({
@@ -1040,15 +1256,22 @@ var SQLEditor = () => {
 			});
 			return;
 		}
-		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
-		if (resolution.error || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
+		if (!isCurrentConnection(activeTab.lastExecutedConnection)) {
+			snackbarController.open({
+				type: "error",
+				message: t("studio_sql_cannot_edit_other_connection")
+			});
+			return;
+		}
+		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",
@@ -1063,61 +1286,63 @@ var SQLEditor = () => {
 		});
 	}, [
 		activeTab.lastExecutedSql,
-		schemas,
-		snackbarController
+		activeTab.lastExecutedConnection,
+		isCurrentConnection,
+		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;
-		const resolution = determineTableAndPK(activeTab.lastExecutedSql, columnKey, schemas);
-		if (resolution.error || !resolution.tableName || !resolution.primaryKeys || resolution.primaryKeys.length === 0) {
+		if (text === editingCell.initialValue) return;
+		const newValue = text === "" ? null : text;
+		const connection = activeTab.lastExecutedConnection;
+		if (!isCurrentConnection(connection)) {
 			snackbarController.open({
 				type: "error",
-				message: resolution.error || "Resolution failed."
+				message: t("studio_sql_cannot_edit_other_connection")
 			});
 			return;
 		}
-		const tableName = resolution.tableName;
+		const resolution = resolveEdit(columnKey);
+		if (!resolution.target) {
+			snackbarController.open({
+				type: "error",
+				message: t(resolution.refusal.key, resolution.refusal.params)
+			});
+			return;
+		}
+		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: selectedDatabase,
-					role: selectedRole
-				});
-				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",
@@ -1126,14 +1351,15 @@ var SQLEditor = () => {
 		}
 	}, [
 		editingCell,
-		schemas,
+		resolveEdit,
 		activeTab.lastExecutedSql,
+		activeTab.lastExecutedConnection,
 		activeTab.results,
+		isCurrentConnection,
 		databaseAdmin,
 		updateActiveTab,
 		snackbarController,
-		selectedDatabase,
-		selectedRole
+		t
 	]);
 	const [columnWidths, setColumnWidths] = useState(() => {
 		return readStoredJson(`rebase_sql_column_widths_${client?.baseUrl ? client.baseUrl.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9]/g, "_") : "default"}`, {
@@ -1200,7 +1426,11 @@ var SQLEditor = () => {
 			loading: false,
 			error: null,
 			execTime: null,
-			lastExecutedSql: null
+			lastExecutedSql: null,
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		}]);
 		setActiveTabId(newId);
 	};
@@ -1229,15 +1459,28 @@ 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);
 	const handleExplain = async () => {
-		const explainSql = `EXPLAIN (FORMAT JSON, ANALYZE) ${activeTab.sql}`;
+		const explainSql = buildExplainSql(editorHandle.current?.getSelectedText() ?? activeTab.sql);
+		if (!explainSql) {
+			updateActiveTab({
+				results: null,
+				error: t("studio_sql_explain_single_statement")
+			});
+			return;
+		}
 		updateActiveTab({
 			loading: true,
 			error: null,
-			results: null
+			results: null,
+			lastExecutedSql: null,
+			lastExecutedConnection: null,
+			ranAs: null,
+			lastProvenance: null,
+			notices: []
 		});
 		const start = performance.now();
 		try {
@@ -1259,31 +1502,39 @@ var SQLEditor = () => {
 		}
 	};
 	const executeRun = useCallback(async (sqlOverride) => {
-		let sqlToRun = sqlOverride || activeTab.sql;
-		const upperSql = sqlToRun.toUpperCase();
-		const isAggregate = /\b(COUNT|SUM|AVG|MIN|MAX)\s*\(/i.test(sqlToRun);
-		const isExplain = /\bEXPLAIN\b/i.test(sqlToRun);
-		if (autoLimit && upperSql.includes("SELECT") && !upperSql.includes("LIMIT") && !isAggregate && !isExplain) {
-			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
+					lastExecutedSql: sqlToRun,
+					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) {
@@ -1304,14 +1555,7 @@ var SQLEditor = () => {
 	const handleRun = useCallback(async (selectedText) => {
 		const sqlTarget = selectedText || activeTab.sql;
 		if (!sqlTarget.trim()) return;
-		const hasDestructive = [
-			"DELETE",
-			"DROP",
-			"TRUNCATE",
-			"UPDATE"
-		].some((kw) => sqlTarget.toUpperCase().includes(kw));
-		const hasWhere = sqlTarget.toUpperCase().includes("WHERE");
-		if (hasDestructive && (!hasWhere || sqlTarget.toUpperCase().includes("DROP") || sqlTarget.toUpperCase().includes("TRUNCATE"))) {
+		if (needsDestructiveConfirmation(sqlTarget)) {
 			setPendingAction(() => () => executeRun(selectedText));
 			setIsConfirmDialogOpen(true);
 			return;
@@ -1320,12 +1564,13 @@ 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";
 				if (!activeElement?.className?.includes("monaco-mouse-cursor-text") && !isInput) {
 					e.preventDefault();
-					handleRun();
+					handleRun(editorHandle.current?.getSelectedText());
 				}
 			}
 		};
@@ -1468,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) => ({
@@ -1547,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();
@@ -1603,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
@@ -1753,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 })
 									})
 								}),
@@ -1833,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", {
@@ -1866,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") : ""]
@@ -1876,7 +2125,7 @@ var SQLEditor = () => {
 									})
 								}),
 								/* @__PURE__ */ jsxs(Button, {
-									onClick: () => handleRun(),
+									onClick: () => handleRun(editorHandle.current?.getSelectedText()),
 									disabled: loading,
 									size: "small",
 									color: "primary",
@@ -1898,6 +2147,7 @@ var SQLEditor = () => {
 						firstPanel: /* @__PURE__ */ jsx("div", {
 							className: "h-full w-full relative flex flex-col min-h-0",
 							children: /* @__PURE__ */ jsx(MonacoEditor, {
+								ref: editorHandle,
 								value: sql,
 								onChange: (v) => setSql(v || ""),
 								onRun: handleRun,
@@ -1906,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()
-							})]
+							]
 						})
 					})]
 				})
@@ -1974,4 +2246,4 @@ var SQLEditor = () => {
 //#endregion
 export { SQLEditor };
 
-//# sourceMappingURL=SQLEditor-sdtoZv5F.js.map
+//# sourceMappingURL=SQLEditor-1An7w0j6.js.map