@tablecraft-app/plugin-duckdb-linux-x64 1.28.0 → 1.35.0

package/index.js

@@ -52,10 +52,12 @@ var PluginError = class extends Error {
 	code;
 	name = "PluginError";
 	position;
+	sent;
 	constructor(code, message, options) {
 		super(message, options);
 		this.code = code;
 		this.position = options?.position;
+		if (options?.sent !== void 0) this.sent = options.sent;
 	}
 };
 /**
@@ -5535,7 +5537,8 @@ var CAPABILITIES$1 = [
 	"maintenance",
 	"coordination",
 	"bulkTransfer",
-	"savepoints"
+	"savepoints",
+	"rowLimit"
 ];
 /**
 * Whether a switch over `targets` can name `namespace`. Not by `Namespace.kind` alone: MySQL lists
@@ -5593,6 +5596,8 @@ var connectionFieldSchema = strictObject({
 	]).optional(),
 	required: boolean().optional(),
 	placeholder: string$1().optional(),
+	/** Explains the field in an (i) beside it: what it does, its unit, and what blank means. */
+	hint: string$1().min(1).optional(),
 	/** The choices of a `select`, in display order. */
 	options: array(strictObject({
 		value: string$1(),
@@ -5824,6 +5829,9 @@ strictObject({
 }).refine((manifest) => !manifest.capabilities.includes("savepoints") || manifest.capabilities.includes("sql") && manifest.capabilities.includes("transactions"), {
 	message: "the savepoints capability requires sql and transactions",
 	path: ["capabilities"]
+}).refine((manifest) => !manifest.capabilities.includes("rowLimit") || manifest.capabilities.includes("sql"), {
+	message: "the rowLimit capability requires sql",
+	path: ["capabilities"]
 });
 // ../plugin-api/src/services.ts
 var SESSION_KEYS = {
@@ -5854,7 +5862,8 @@ var LANGUAGE_KEYS = {
 	bulkInsert: true,
 	objects: true,
 	routineCall: true,
-	savepoints: true
+	savepoints: true,
+	rowLimit: true
 };
 Object.keys(SESSION_KEYS);
 Object.keys(LANGUAGE_KEYS);
@@ -16436,7 +16445,7 @@ var NOT_A_NAME$1 = /* @__PURE__ */ new Set([
 	"NULL"
 ]);
 var AS$5 = "AS";
-var WITH$5 = "WITH";
+var WITH$6 = "WITH";
 var RECURSIVE$1 = "RECURSIVE";
 var CTE_MODIFIERS$1 = /* @__PURE__ */ new Set(["NOT", "MATERIALIZED"]);
 var SELECT_MODIFIERS$2 = /* @__PURE__ */ new Set(["DISTINCT", "ALL"]);
@@ -16592,7 +16601,7 @@ var QueryReader = class {
 	}
 	read() {
 		const statement = this.#statement;
-		if (statement.word(this.#index()) === WITH$5) this.#readCtes();
+		if (statement.word(this.#index()) === WITH$6) this.#readCtes();
 		let expectRelation = false;
 		let fromList = false;
 		let into = false;
@@ -17048,7 +17057,7 @@ var SELECT_READ_ONLY_REASONS = {
 	derived: "the result reads a subquery or function, not a table",
 	noTable: "the result reads no table"
 };
-var SELECT$1 = "SELECT";
+var SELECT$2 = "SELECT";
 var FROM = "FROM";
 var AS$4 = "AS";
 var STAR$1 = "*";
@@ -17060,7 +17069,7 @@ var OVER = "OVER";
 var ONLY = "ONLY";
 var ON$2 = "ON";
 var NOT = "NOT";
-var WITH$4 = "WITH";
+var WITH$5 = "WITH";
 var DISTINCT = /* @__PURE__ */ new Set([
 	"DISTINCT",
 	"DISTINCTROW",
@@ -17087,7 +17096,7 @@ var JOINS = /* @__PURE__ */ new Set([
 	"OUTER"
 ]);
 var GROUPING = /* @__PURE__ */ new Set(["GROUP", "HAVING"]);
-var SET_OPERATIONS = /* @__PURE__ */ new Set([
+var SET_OPERATIONS$1 = /* @__PURE__ */ new Set([
 	"UNION",
 	"INTERSECT",
 	"EXCEPT",
@@ -17185,7 +17194,7 @@ var Reader = class {
 			if (symbol === CLOSE$4) subqueries.pop();
 			depth.push(subqueries.length);
 			inSubquery.push(subqueries.some(Boolean));
-			if (symbol === OPEN$5) subqueries.push(this.word(this.tokens[index + 1]) === SELECT$1);
+			if (symbol === OPEN$5) subqueries.push(this.word(this.tokens[index + 1]) === SELECT$2);
 		});
 		return {
 			depth,
@@ -17253,7 +17262,7 @@ function tailRefusal(reader, from, depth) {
 	if (from < tokens.length && (first === null || !TAIL_CLAUSES.has(first))) {
 		if (reader.symbol(tokens[from]) === COMMA$7 || first !== null && JOINS.has(first)) return SELECT_READ_ONLY_REASONS.joins;
 		if (first !== null && GROUPING.has(first)) return SELECT_READ_ONLY_REASONS.aggregates;
-		if (first !== null && SET_OPERATIONS.has(first)) return SELECT_READ_ONLY_REASONS.combines;
+		if (first !== null && SET_OPERATIONS$1.has(first)) return SELECT_READ_ONLY_REASONS.combines;
 		return SELECT_READ_ONLY_REASONS.notSelect;
 	}
 	for (let at = from; at < tokens.length; at += 1) {
@@ -17261,7 +17270,7 @@ function tailRefusal(reader, from, depth) {
 		const word = reader.word(tokens[at]);
 		if (word === null) continue;
 		if (GROUPING.has(word)) return SELECT_READ_ONLY_REASONS.aggregates;
-		if (SET_OPERATIONS.has(word)) return SELECT_READ_ONLY_REASONS.combines;
+		if (SET_OPERATIONS$1.has(word)) return SELECT_READ_ONLY_REASONS.combines;
 		if (JOINS.has(word) || word === ON$2 && at > from) return SELECT_READ_ONLY_REASONS.joins;
 		if (OTHER_TAIL.has(word) && word !== NOT) return SELECT_READ_ONLY_REASONS.notSelect;
 	}
@@ -17275,9 +17284,9 @@ function parseSimpleSelect(sql, dialect) {
 	const tokens = significantTokens(sql, dialect).filter((token) => token.kind !== "delimiter");
 	const reader = new Reader(sql, tokens);
 	const head = reader.word(tokens[0]);
-	if (head === WITH$4) return { readOnly: SELECT_READ_ONLY_REASONS.with };
+	if (head === WITH$5) return { readOnly: SELECT_READ_ONLY_REASONS.with };
 	if (reader.symbol(tokens[0]) === OPEN$5) return { readOnly: SELECT_READ_ONLY_REASONS.combines };
-	if (head !== SELECT$1) return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
+	if (head !== SELECT$2) return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
 	const { depth, inSubquery } = reader.depths();
 	let at = 1;
 	const modifier = reader.word(tokens[at]);
@@ -17322,7 +17331,7 @@ function parseSimpleSelect(sql, dialect) {
 	};
 }
 function isClauseWord(word) {
-	return TAIL_CLAUSES.has(word) || JOINS.has(word) || GROUPING.has(word) || SET_OPERATIONS.has(word) || OTHER_TAIL.has(word) || word === ON$2 || word === ONLY;
+	return TAIL_CLAUSES.has(word) || JOINS.has(word) || GROUPING.has(word) || SET_OPERATIONS$1.has(word) || OTHER_TAIL.has(word) || word === ON$2 || word === ONLY;
 }
 // ../plugin-api/src/sql/namespace.ts
 var USE = "USE";
@@ -18530,10 +18539,10 @@ function sqlCompleter(options) {
 	};
 }
 // ../plugin-api/src/sql/words.ts
-var OPEN_PAREN = "(";
-var CLOSE_PAREN = ")";
-var WITH$3 = "WITH";
-var MAIN_VERBS = /* @__PURE__ */ new Set([
+var OPEN_PAREN$1 = "(";
+var CLOSE_PAREN$1 = ")";
+var WITH$4 = "WITH";
+var MAIN_VERBS$1 = /* @__PURE__ */ new Set([
 	"SELECT",
 	"INSERT",
 	"UPDATE",
@@ -18546,8 +18555,8 @@ function words(sql, tokens) {
 	let depth = 0;
 	for (const token of tokens) if (token.kind === "symbol") {
 		const char = sql.charAt(token.from);
-		if (char === OPEN_PAREN) depth += 1;
-		else if (char === CLOSE_PAREN) depth = Math.max(0, depth - 1);
+		if (char === OPEN_PAREN$1) depth += 1;
+		else if (char === CLOSE_PAREN$1) depth = Math.max(0, depth - 1);
 	} else if (token.kind === "word") found.push({
 		word: wordOf(sql, token),
 		depth
@@ -18556,8 +18565,8 @@ function words(sql, tokens) {
 }
 /** The verb that decides what a `WITH …` statement does: the first one outside the CTEs' parentheses. */
 function mainVerb(list) {
-	if (list[0]?.word !== WITH$3) return 0;
-	const index = list.findIndex((entry, at) => at > 0 && entry.depth === 0 && MAIN_VERBS.has(entry.word));
+	if (list[0]?.word !== WITH$4) return 0;
+	const index = list.findIndex((entry, at) => at > 0 && entry.depth === 0 && MAIN_VERBS$1.has(entry.word));
 	return index < 0 ? 0 : index;
 }
 /** MySQL reads `DESCRIBE` and `DESC` before a statement as `EXPLAIN`, `ANALYZE` included. */
@@ -18620,7 +18629,7 @@ var BY_OWNERS$1 = /* @__PURE__ */ new Set([
 var ON$1 = "ON";
 /** `ON DUPLICATE KEY UPDATE` and `ON CONFLICT`: an `ON` that starts an action, not a join condition. */
 var ON_ACTIONS = /* @__PURE__ */ new Set(["DUPLICATE", "CONFLICT"]);
-var WITH$2 = "WITH";
+var WITH$3 = "WITH";
 var CREATE$1 = "CREATE";
 var AS$3 = "AS";
 /** Statements whose clauses the inspections understand; anything else gets only the lexical checks. */
@@ -18632,7 +18641,7 @@ var INSPECTED_VERBS = /* @__PURE__ */ new Set([
 	"REPLACE"
 ]);
 var CREATED_FROM_QUERY = /* @__PURE__ */ new Set(["TABLE", "VIEW"]);
-var QUERY_STARTS = /* @__PURE__ */ new Set(["SELECT", WITH$2]);
+var QUERY_STARTS = /* @__PURE__ */ new Set(["SELECT", WITH$3]);
 /** Words an expression may hold that no built-in keyword list names, so they are never taken for columns. */
 var EXPRESSION_WORDS = [
 	"INTERVAL",
@@ -19272,7 +19281,7 @@ var ASC = "ASC";
 var ELSE$1 = "ELSE";
 var END$3 = "END";
 var AS$1 = "AS";
-var WITH$1 = "WITH";
+var WITH$2 = "WITH";
 var ROW = "ROW";
 var VALUES_WORDS = /* @__PURE__ */ new Set(["VALUES", "VALUE"]);
 var RECURSIVE = "RECURSIVE";
@@ -19567,7 +19576,7 @@ function cteRemoval(view, nameIndex, close) {
 	}
 	const withIndex = view.word(nameIndex - 1) === RECURSIVE ? nameIndex - 2 : nameIndex - 1;
 	const withToken = view.token(withIndex);
-	if (view.word(withIndex) !== WITH$1 || withToken === void 0 || following === void 0) return null;
+	if (view.word(withIndex) !== WITH$2 || withToken === void 0 || following === void 0) return null;
 	return removal("Remove CTE", {
 		from: withToken.from,
 		to: following.from
@@ -19652,7 +19661,7 @@ var OPEN$1 = "(";
 var CLOSE$1 = ")";
 var COMMA$3 = ",";
 var BY = "BY";
-var SELECT = "SELECT";
+var SELECT$1 = "SELECT";
 var EXPRESSION_EXPECTED = "Expression expected";
 /** Keywords that start the next clause, so a clause keyword right before one has no body. */
 var CLAUSE_STARTS = /* @__PURE__ */ new Set([
@@ -19689,7 +19698,7 @@ var NEEDS_BODY = /* @__PURE__ */ new Set([
 	"HAVING",
 	"ON",
 	"SET",
-	SELECT
+	SELECT$1
 ]);
 var BY_OWNERS = /* @__PURE__ */ new Set([
 	"ORDER",
@@ -19733,14 +19742,14 @@ function emptyClause(view, index) {
 		if (owner === null || !BY_OWNERS.has(owner)) return null;
 		first = index - 1;
 	} else if (!NEEDS_BODY.has(word)) return null;
-	if (word === SELECT) while (SELECT_MODIFIERS$1.has(view.word(last + 1) ?? "")) last += 1;
+	if (word === SELECT$1) while (SELECT_MODIFIERS$1.has(view.word(last + 1) ?? "")) last += 1;
 	if (!nothingFollows(view, last)) return null;
 	const start = view.token(first);
 	const end = view.token(last);
 	if (start === void 0 || end === void 0) return null;
 	const label = view.text.slice(start.from, end.to).toUpperCase().replace(/\s+/g, " ");
 	const fixes = [];
-	if (word !== SELECT) {
+	if (word !== SELECT$1) {
 		const following = view.token(last + 1);
 		const span = following === void 0 || view.isSymbol(last + 1, CLOSE$1) ? view.withLeadingSpace(first, last) : {
 			from: start.from,
@@ -19984,7 +19993,7 @@ var START$1 = "START";
 var TRANSACTION = "TRANSACTION";
 var WHERE = "WHERE";
 var LIMIT$1 = "LIMIT";
-var WITH = "WITH";
+var WITH$1 = "WITH";
 /** Prefixes the explained statement's destructive reason, so the confirmation says why it matters. */
 var EXPLAIN_ANALYZE_REASON_PREFIX = "EXPLAIN ANALYZE runs it: ";
 function hasTopLevel(list, from, word) {
@@ -20043,7 +20052,7 @@ function classifyWords(list) {
 	const verbAt = mainVerb(list);
 	const verb = list[verbAt]?.word ?? first;
 	return {
-		kind: first === WITH && verbAt === 0 ? "read" : KINDS.get(verb) ?? "other",
+		kind: first === WITH$1 && verbAt === 0 ? "read" : KINDS.get(verb) ?? "other",
 		destructive: destructiveReason(list, verbAt)
 	};
 }
@@ -28350,7 +28359,7 @@ var SET_OPERATORS = /* @__PURE__ */ new Set([
 	"EXCEPT",
 	"MINUS"
 ]);
-var SET_QUANTIFIERS = /* @__PURE__ */ new Set(["ALL", "DISTINCT"]);
+var SET_QUANTIFIERS$1 = /* @__PURE__ */ new Set(["ALL", "DISTINCT"]);
 var SELECT_MODIFIERS = /* @__PURE__ */ new Set([
 	"ALL",
 	"DISTINCT",
@@ -28637,7 +28646,7 @@ var AlignedPrinter = class {
 			if (node.type === "tok" && node.keyword && SET_OPERATORS.has(node.upper)) {
 				const operator = [node];
 				const quantifier = nodes[index + 1];
-				if (quantifier?.type === "tok" && quantifier.keyword && SET_QUANTIFIERS.has(quantifier.upper)) {
+				if (quantifier?.type === "tok" && quantifier.keyword && SET_QUANTIFIERS$1.has(quantifier.upper)) {
 					operator.push(quantifier);
 					index += 1;
 				}
@@ -29583,6 +29592,121 @@ function sqlExplainable(options) {
 	};
 	return { explainable };
 }
+// ../plugin-api/src/sql/limit.ts
+var SELECT = "SELECT";
+var WITH = "WITH";
+var TOP = "TOP";
+var OPEN_PAREN = "(";
+var CLOSE_PAREN = ")";
+/** What may stand between `SELECT` and `TOP`. */
+var SET_QUANTIFIERS = /* @__PURE__ */ new Set(["ALL", "DISTINCT"]);
+var MAIN_VERBS = /* @__PURE__ */ new Set([
+	"SELECT",
+	"INSERT",
+	"UPDATE",
+	"DELETE",
+	"MERGE"
+]);
+/** A top-level row limit the statement already has. */
+var OWN_LIMITS = /* @__PURE__ */ new Set([
+	"LIMIT",
+	"OFFSET",
+	"FETCH"
+]);
+/**
+* Top-level words that make a SELECT more than a read of rows a limit may trim: `INTO` writes,
+* `FOR UPDATE` and `LOCK IN SHARE MODE` lock what they read, `PROCEDURE` hands the rows to MySQL.
+*/
+var NOT_A_PLAIN_READ = /* @__PURE__ */ new Set([
+	"INTO",
+	"FOR",
+	"LOCK",
+	"PROCEDURE"
+]);
+/** A data-modifying CTE or subquery runs whatever the limit trims. */
+var WRITES = /* @__PURE__ */ new Set([
+	"INSERT",
+	"UPDATE",
+	"DELETE",
+	"MERGE"
+]);
+/** `TOP` limits only the SELECT it opens, not the whole combined query. */
+var SET_OPERATIONS = /* @__PURE__ */ new Set([
+	"UNION",
+	"INTERSECT",
+	"EXCEPT",
+	"MINUS"
+]);
+function placedWords(sql, tokens) {
+	const found = [];
+	let depth = 0;
+	for (const token of tokens) if (token.kind === "symbol") {
+		const char = sql.charAt(token.from);
+		if (char === OPEN_PAREN) depth += 1;
+		else if (char === CLOSE_PAREN) depth = Math.max(0, depth - 1);
+	} else if (token.kind === "word") found.push({
+		word: wordOf(sql, token),
+		depth,
+		token
+	});
+	return found;
+}
+function mainSelect(list) {
+	const first = list[0];
+	if (first === void 0 || first.depth !== 0) return null;
+	if (first.word === SELECT) return 0;
+	if (first.word !== WITH) return null;
+	const verb = list.findIndex((entry, at) => at > 0 && entry.depth === 0 && MAIN_VERBS.has(entry.word));
+	return verb > 0 && list[verb]?.word === SELECT ? verb : null;
+}
+/** The statement's tokens up to its delimiter; null when another statement follows it. */
+function ownTokens(tokens) {
+	const end = tokens.findIndex((token) => token.kind === "delimiter");
+	if (end < 0) return tokens;
+	return tokens.slice(end).every((token) => token.kind === "delimiter") ? tokens.slice(0, end) : null;
+}
+function insert(sql, offset, text) {
+	return {
+		sql: sql.slice(0, offset) + text + sql.slice(offset),
+		inserted: {
+			offset,
+			length: text.length
+		}
+	};
+}
+function topOffset(list, verb) {
+	let at = verb + 1;
+	if (SET_QUANTIFIERS.has(list[at]?.word ?? "")) at += 1;
+	if (list[at]?.word === TOP) return null;
+	return list[at - 1]?.token.to ?? null;
+}
+/**
+* The `rowLimit` language service for a dialect (decision 162). It limits a plain SELECT, `WITH`
+* included, by one insertion, and answers null for anything it cannot limit without changing what
+* the statement does or reading it wrongly: another verb, a limit of its own, `INTO`, a locking
+* read, a data-modifying CTE, more than one statement, and under `top` a combined query.
+*/
+function sqlRowLimiter(options, style) {
+	return { limit(sql, rows) {
+		if (!Number.isSafeInteger(rows) || rows < 1) throw new RangeError(`A row limit is a positive integer, not ${rows}`);
+		const tokens = ownTokens(significantTokens(sql, options));
+		const last = tokens?.at(-1);
+		if (tokens === null || last === void 0) return null;
+		const list = placedWords(sql, tokens);
+		const verb = mainSelect(list);
+		if (verb === null) return null;
+		if (list.some((entry) => WRITES.has(entry.word))) return null;
+		const top = list.slice(verb + 1).filter((entry) => entry.depth === 0);
+		if (top.some((entry) => OWN_LIMITS.has(entry.word) || NOT_A_PLAIN_READ.has(entry.word))) return null;
+		if (style === "top") {
+			if (top.some((entry) => SET_OPERATIONS.has(entry.word))) return null;
+			const offset = topOffset(list, verb);
+			return offset === null ? null : insert(sql, offset, ` ${TOP} (${rows})`);
+		}
+		const clause = style === "limit" ? ` LIMIT ${rows}` : ` FETCH FIRST ${rows} ROWS ONLY`;
+		return insert(sql, last.to, clause);
+	} };
+}
 // ../../plugins/duckdb/src/explain.ts
 /** What DuckDB's `EXPLAIN` plans; anything else answers an empty tree. */
 var EXPLAIN_VERBS = [
@@ -40325,7 +40449,8 @@ var CAPABILITIES = [
 	"ddl",
 	"explain",
 	"explainAnalyze",
-	"bulkInsert"
+	"bulkInsert",
+	"rowLimit"
 ];
 /** DuckDB reads PostgreSQL's lexis: dollar quotes and nested block comments. */
 var DIALECT = {
@@ -40430,7 +40555,8 @@ var language = {
 			keywords: KEYWORDS,
 			types: IMPORT_TYPES,
 			decimal: duckdbDecimal
-		})
+		}),
+		rowLimit: sqlRowLimiter(DIALECT, "limit")
 	}
 };
 // ../../plugins/duckdb/src/errorPosition.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft-app/plugin-duckdb-linux-x64",
-  "version": "1.28.0",
+  "version": "1.35.0",
   "description": "The DuckDB datasource plugin for TableCraft, downloaded by the app when a data source needs it. This package is for linux-x64.",
   "license": "MIT",
   "type": "module",
@@ -27,7 +27,7 @@
   },
   "tableCraft": {
     "id": "duckdb",
-    "apiVersion": "2.0.0",
+    "apiVersion": "2.2.0",
     "platform": "linux-x64"
   },
   "os": [

package/table-craft-plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "duckdb",
   "name": "DuckDB",
-  "version": "1.28.0",
-  "apiVersion": "2.0.0",
+  "version": "1.35.0",
+  "apiVersion": "2.2.0",
   "entry": "index.js",
   "capabilities": [
     "sql",
@@ -12,7 +12,8 @@
     "ddl",
     "explain",
     "explainAnalyze",
-    "bulkInsert"
+    "bulkInsert",
+    "rowLimit"
   ],
   "highlight": "postgresql",
   "brands": [