@intentius/chant-lexicon-sql 0.120.0 → 0.121.1

package/dist/clickhouse/import/inlined.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Finding a SQL user-defined function in what ClickHouse stored (#3745).
+ *
+ * ClickHouse does not keep a call to a SQL function in a view's query or a
+ * column's DEFAULT: it writes the function's body in place of the call, with
+ * the arguments substituted, and a nested call expanded the same way.
+ * `CREATE FUNCTION tax AS x -> (x * 0.2)` used as `tax(amt)` reads back as
+ * `amt * 0.2`. So an import can't look for the name; it looks for the body.
+ *
+ * Each function's body is expanded (a call to another function becomes that
+ * function's body), its parameters become wildcards, and the result is
+ * matched against the stored statement's tokens. Parentheses that only
+ * group are dropped on both sides, since the server adds or leaves them by
+ * precedence where the body lands. A wildcard matches one balanced
+ * expression, and a parameter used twice must match the same text twice.
+ *
+ * A function whose body is just a parameter (`x -> x`) leaves nothing to
+ * look for, so it is never found this way.
+ */
+import { type Token } from "../tokens.js";
+/** One item of a pattern: a token's text, or the parameter at `arg`. */
+type Item = {
+    lit: string;
+} | {
+    arg: number;
+};
+/** A function's parameters and body, from `CREATE FUNCTION name AS (x, y) -> body`; undefined when it doesn't read that way. */
+export declare function functionLambda(statement: string): {
+    params: string[];
+    body: Token[];
+} | undefined;
+/** What to look for: the function's expanded body, with its parameters as wildcards. Undefined when nothing but a parameter is left to match. */
+export declare function inlinedPattern(name: string, lambdas: ReadonlyMap<string, {
+    params: string[];
+    body: Token[];
+}>): Item[] | undefined;
+/** Whether `pattern` appears in `statement`'s tokens. */
+export declare function containsInlined(statement: string, pattern: readonly Item[]): boolean;
+/**
+ * The functions among `functions` whose bodies appear inlined in any of
+ * `statements`. A function is matched with the others' bodies expanded into
+ * its own, as the server does.
+ */
+export declare function inlinedFunctions(statements: readonly string[], functions: ReadonlyArray<{
+    name: string;
+    statement: string;
+}>): string[];
+export {};
+//# sourceMappingURL=inlined.d.ts.map

package/dist/clickhouse/import/inlined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inlined.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/inlined.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAA0B,KAAK,KAAK,EAAE,MAAM,WAAW,CAAC;AAG/D,wEAAwE;AACxE,KAAK,IAAI,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9C,gIAAgI;AAChI,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,KAAK,EAAE,CAAA;CAAE,GAAG,SAAS,CAiBjG;AAuFD,iJAAiJ;AACjJ,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,KAAK,EAAE,CAAA;CAAE,CAAC,GAAG,IAAI,EAAE,GAAG,SAAS,CAOlI;AAKD,yDAAyD;AACzD,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,IAAI,EAAE,GAAG,OAAO,CAmCpF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,SAAS,EAAE,aAAa,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,EAAE,CAYvI"}

package/dist/clickhouse/import/live-export.d.ts

@@ -17,9 +17,11 @@
  *   `goose_db_version`) is left out with a warning (#3676), as on Postgres.
  * - A SQL user-defined function belongs to no database, and every project's
  *   functions sit side by side on a server (#3718). Without a selector, an
- *   import adopts only the functions the imported objects call (and those
+ *   import adopts only the functions the imported objects use (and those
  *   functions call), and the ones `sql.profiles.<env>.importFunctions` names;
- *   a warning names the rest. A function carries no comment, so `owned` does
+ *   a warning names the rest. ClickHouse stores a call as the function's body
+ *   (#3745), so a use is found by that body (`./inlined.ts`) as well as by
+ *   the name. A function carries no comment, so `owned` does
  *   not apply to it.
  */
 import type { ExportedTemplate, ResourceSelector } from "@intentius/chant/lexicon";
@@ -29,7 +31,8 @@ import type { LiveObject } from "../live/catalog.js";
 export declare function calledFunctions(ddl: string, names: ReadonlySet<string>): string[];
 /**
  * The functions an import adopts (#3718): those the objects call, those
- * `patterns` name, and the functions those call in turn; and the rest.
+ * whose bodies the objects hold in place of a call (#3745, `./inlined.ts`),
+ * those `patterns` name, and the functions those call in turn; and the rest.
  */
 export declare function scopedFunctions(objects: readonly LiveObject[], functions: readonly LiveObject[], patterns?: readonly string[]): {
     adopted: LiveObject[];

package/dist/clickhouse/import/live-export.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAWjF;AAKD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,SAAS,EAAE,SAAS,UAAU,EAAE,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO,GAAG;IAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAehL;AAED,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAsCvF"}
+{"version":3,"file":"live-export.d.ts","sourceRoot":"","sources":["../../../src/clickhouse/import/live-export.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACnF,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAOhE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CAWjF;AAKD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,EAAE,SAAS,EAAE,SAAS,UAAU,EAAE,EAAE,QAAQ,GAAE,SAAS,MAAM,EAAO,GAAG;IAAE,OAAO,EAAE,UAAU,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAgBhL;AAED,MAAM,WAAW,aAAc,SAAQ,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAsCvF"}

package/dist/config.d.ts

@@ -89,10 +89,12 @@ export declare const sqlProfileSchema: z.ZodObject<{
     defaultDatabase: z.ZodOptional<z.ZodString>;
     /**
      * ClickHouse import (#3718): the SQL user-defined functions `chant import
-     * --from <env>` adopts besides those the imported objects call, by name, or
+     * --from <env>` adopts besides those the imported objects use, by name, or
      * by prefix with a trailing `*` (`shop_*`). A function belongs to no
      * database, so without this only the functions the imported tables, views
-     * and dictionaries call (and the functions those call) are imported.
+     * and dictionaries use (and the functions those call) are imported. A use
+     * is found by name or, since ClickHouse stores a call as the function's
+     * body, by that body (#3745).
      */
     importFunctions: z.ZodOptional<z.ZodArray<z.ZodString>>;
     /**
@@ -256,10 +258,12 @@ export declare const sqlConfigSchema: z.ZodObject<{
         defaultDatabase: z.ZodOptional<z.ZodString>;
         /**
          * ClickHouse import (#3718): the SQL user-defined functions `chant import
-         * --from <env>` adopts besides those the imported objects call, by name, or
+         * --from <env>` adopts besides those the imported objects use, by name, or
          * by prefix with a trailing `*` (`shop_*`). A function belongs to no
          * database, so without this only the functions the imported tables, views
-         * and dictionaries call (and the functions those call) are imported.
+         * and dictionaries use (and the functions those call) are imported. A use
+         * is found by name or, since ClickHouse stores a call as the function's
+         * body, by that body (#3745).
          */
         importFunctions: z.ZodOptional<z.ZodArray<z.ZodString>>;
         /**

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAmC3D,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,2EAA2E;;;;IAE3E;;;;;;;OAOG;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;IAEH,qFAAqF;;IAErF;;;;;;OAMG;;IAEH;;;;;;;;;OASG;;;;;;;;;;;;;;IAEH;;;;;OAKG;;IAEH,4FAA4F;;IAE5F;;;;;OAKG;;IAEH;;;;OAIG;;;;;;;;;IAEH;;;;;;;;OAQG;;IAEH;;;OAGG;;IAEH;;;;OAIG;;IAEH;;;;;;;;;OASG;;kBAEH,CAAC;AAcH,eAAO,MAAM,eAAe;IAC1B,iEAAiE;;;;;;;;IAEjE;;;;OAIG;;;;;;;;;IAEH;;;;OAIG;;IAMH,wCAAwC;;QApIxC;;;;;WAKG;;QAEH,2EAA2E;;;;QAE3E;;;;;;;WAOG;;;;;;;;;;;;;;;;;;QAEH;;;;WAIG;;QAEH,qFAAqF;;QAErF;;;;;;WAMG;;QAEH;;;;;;;;;WASG;;;;;;;;;;;;;;QAEH;;;;;WAKG;;QAEH,4FAA4F;;QAE5F;;;;;WAKG;;QAEH;;;;WAIG;;;;;;;;;QAEH;;;;;;;;WAQG;;QAEH;;;WAGG;;QAEH;;;;WAIG;;QAEH;;;;;;;;;WASG;;;kBAqCH,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,OAAO,QAAQ,yBAAyB,CAAC;IACvC,UAAU,WAAW;QACnB,GAAG,CAAC,EAAE,SAAS,CAAC;KACjB;CACF;AAED,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAmC3D,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,2EAA2E;;;;IAE3E;;;;;;;OAOG;;;;;;;;;;;;;;;;;;IAEH;;;;OAIG;;IAEH,qFAAqF;;IAErF;;;;;;;;OAQG;;IAEH;;;;;;;;;OASG;;;;;;;;;;;;;;IAEH;;;;;OAKG;;IAEH,4FAA4F;;IAE5F;;;;;OAKG;;IAEH;;;;OAIG;;;;;;;;;IAEH;;;;;;;;OAQG;;IAEH;;;OAGG;;IAEH;;;;OAIG;;IAEH;;;;;;;;;OASG;;kBAEH,CAAC;AAcH,eAAO,MAAM,eAAe;IAC1B,iEAAiE;;;;;;;;IAEjE;;;;OAIG;;;;;;;;;IAEH;;;;OAIG;;IAMH,wCAAwC;;QAtIxC;;;;;WAKG;;QAEH,2EAA2E;;;;QAE3E;;;;;;;WAOG;;;;;;;;;;;;;;;;;;QAEH;;;;WAIG;;QAEH,qFAAqF;;QAErF;;;;;;;;WAQG;;QAEH;;;;;;;;;WASG;;;;;;;;;;;;;;QAEH;;;;;WAKG;;QAEH,4FAA4F;;QAE5F;;;;;WAKG;;QAEH;;;;WAIG;;;;;;;;;QAEH;;;;;;;;WAQG;;QAEH;;;WAGG;;QAEH;;;;WAIG;;QAEH;;;;;;;;;WASG;;;kBAqCH,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAExD,OAAO,QAAQ,yBAAyB,CAAC;IACvC,UAAU,WAAW;QACnB,GAAG,CAAC,EAAE,SAAS,CAAC;KACjB;CACF;AAED,4EAA4E;AAC5E,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC"}

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "e8638782cde7d627ffe77497c2cfb02f0843633475ad78354bdea13255de084e",
+    "manifest.json": "81cfc7a318ff52b02fbc21be6456ae27b73969fd2c3919f4b59c7c3af76fe12e",
     "meta.json": "44b1dcfa5b5e5be2239fdc9614ab6c11d3f1461d64e61d572e3658af6c96aa68",
     "types/index.d.ts": "0286ebb367773e84c76818b0f69cb14cff8328fd2f8c65ed87563c8d5815458c",
     "rules/postgres-templates.ts": "da6e305bc2ff3d0d64a20925fe588e051c2a4b556b37f2581c61c314ef7c580d",
@@ -57,5 +57,5 @@
     "rules/sqlpg117.ts": "3d5c2d57ccdee3cf91c3ba3cb6363750787a850df8ebd75e9cc3f33113303827",
     "rules/sqlpg118.ts": "e2a40a88a9374c4d99d02118ca4c60877ba0c6eb1ce603a93b24f5fd23d81dde"
   },
-  "composite": "ab0994a9da91d9144f35b3d143c52ecae05f9612c94034eba2ba39256b7aef19"
+  "composite": "6fb06c039bfa093fb3afe3e0d1e65910acc7b983612ec1e8bc1cd0db97804a56"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "sql",
-  "version": "0.120.0",
+  "version": "0.121.1",
   "chantVersion": ">=0.1.0",
   "namespace": "SQL",
   "intrinsics": [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-sql",
-  "version": "0.120.0",
+  "version": "0.121.1",
   "description": "SQL lexicon for chant — database schema as typed declarations, one dialect at a time; ClickHouse first, with types read from a pinned server's catalog",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -70,7 +70,7 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@intentius/chant": "^0.120.0",
+    "@intentius/chant": "^0.121.1",
     "typescript": "^5.9.3"
   }
 }

package/src/clickhouse/import/import.test.ts

@@ -188,10 +188,18 @@ describe("live export of SQL functions (#3718)", () => {
           engine: "MergeTree",
           statement: "CREATE TABLE shop.orders\n(\n    `id` UInt64,\n    `net` Float64 DEFAULT shop_net(id)\n)\nENGINE = MergeTree\nORDER BY id",
         },
+        {
+          // ClickHouse stores a call as the function's body (#3745): this is shop_gross(net).
+          database: "shop",
+          name: "gross",
+          engine: "View",
+          statement: "CREATE VIEW shop.gross\n(\n    `g` Float64\n)\nAS SELECT net + (net * 0.07) AS g\nFROM shop.orders",
+        },
       ],
       {
         functions: [
           { name: "other_score", statement: "CREATE FUNCTION other_score AS x -> (x * 2)" },
+          { name: "shop_gross", statement: "CREATE FUNCTION shop_gross AS x -> (x + (x * 0.07))" },
           { name: "shop_net", statement: "CREATE FUNCTION shop_net AS x -> shop_tax(x)" },
           { name: "shop_tax", statement: "CREATE FUNCTION shop_tax AS x -> (x * 0.2)" },
           { name: "shop_unused", statement: "CREATE FUNCTION shop_unused AS x -> x" },
@@ -206,14 +214,14 @@ describe("live export of SQL functions (#3718)", () => {
 
   test("adopts the functions the imported objects call, and the ones those call; a warning names the rest", async () => {
     const ir = await run();
-    expect(ir.resources.map((r) => r.properties.name)).toEqual(["shop", "orders", "shop_net", "shop_tax"]);
+    expect(ir.resources.map((r) => r.properties.name)).toEqual(["shop", "orders", "gross", "shop_gross", "shop_net", "shop_tax"]);
     expect(ir.warnings).toEqual([
-      "2 SQL functions on the server are not imported, since no imported object calls them: other_score, shop_unused. Name them in sql.profiles.x.importFunctions to import them.",
+      "2 SQL functions on the server are not imported, since no imported object uses them: other_score, shop_unused. Name them in sql.profiles.x.importFunctions to import them.",
     ]);
   });
 
   test("importFunctions names more, by name or by prefix", async () => {
-    expect((await run({ importFunctions: ["shop_*"] })).resources.map((r) => r.properties.name)).toEqual(["shop", "orders", "shop_net", "shop_tax", "shop_unused"]);
+    expect((await run({ importFunctions: ["shop_*"] })).resources.map((r) => r.properties.name)).toEqual(["shop", "orders", "gross", "shop_gross", "shop_net", "shop_tax", "shop_unused"]);
     const ir = await run({ importFunctions: ["other_score"] });
     expect(ir.resources.map((r) => r.properties.name)).toContain("other_score");
     expect(ir.warnings).toEqual([expect.stringContaining(": shop_unused.")]);

package/src/clickhouse/import/inlined-functions.e2e.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Import adopts a SQL function a view or a column default uses (#3745),
+ * although ClickHouse stores the function's body there in place of the call.
+ *
+ * `CLICKHOUSE_URL` (with `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD`) names a
+ * running server, such as the one `chant emulator up --lexicon sql` starts.
+ * Without it, a throwaway server at the pin, skipped cleanly when Docker is
+ * not available. Functions are global to the server, so everything here is
+ * named `chant_e2e_3745*` and dropped afterwards.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startScratchServer, type ScratchServer } from "../container";
+import { clickhouseQuery, type ClickHouseEndpoint } from "../http";
+import { clickhouseImage } from "../../spec/pin";
+import { exportResources } from "./live-export";
+
+const PREFIX = "chant_e2e_3745";
+const DB = `${PREFIX}_shop`;
+const TAX = `${PREFIX}_tax`;
+const NET = `${PREFIX}_net`;
+const LABEL = `${PREFIX}_label`;
+const UNUSED = `${PREFIX}_unused`;
+const fromEnv = process.env.CLICKHOUSE_URL;
+const docker = await dockerAvailable();
+const enabled = fromEnv !== undefined || docker;
+let server: ScratchServer | undefined;
+let endpoint: ClickHouseEndpoint;
+const q = (sql: string) => clickhouseQuery(endpoint, sql);
+
+const cleanup = async () => {
+  await q(`DROP DATABASE IF EXISTS ${DB} SYNC`).catch(() => undefined);
+  // NET calls TAX, so it goes first.
+  for (const f of [NET, TAX, LABEL, UNUSED]) await q(`DROP FUNCTION IF EXISTS ${f}`).catch(() => undefined);
+};
+
+beforeAll(async () => {
+  if (!enabled) return;
+  if (fromEnv !== undefined) {
+    endpoint = {
+      url: fromEnv,
+      ...(process.env.CLICKHOUSE_USER ? { user: process.env.CLICKHOUSE_USER } : {}),
+      ...(process.env.CLICKHOUSE_PASSWORD ? { password: process.env.CLICKHOUSE_PASSWORD } : {}),
+    };
+  } else {
+    server = await startScratchServer(clickhouseImage(), { namePrefix: "chant-sql-inlined" });
+    endpoint = server.endpoint;
+  }
+  await cleanup();
+  await q(`CREATE FUNCTION ${TAX} AS (x) -> x * 0.2`);
+  await q(`CREATE FUNCTION ${NET} AS (x, y) -> ${TAX}(x) + if(y > 1, y, 0)`);
+  await q(`CREATE FUNCTION ${LABEL} AS (s) -> concat('[', lower(s), ']')`);
+  await q(`CREATE FUNCTION ${UNUSED} AS (x) -> x - 42`);
+  await q(`CREATE DATABASE ${DB}`);
+  await q(`CREATE TABLE ${DB}.orders (id UInt64, kind String, amt Float64 DEFAULT ${TAX}(id)) ENGINE = MergeTree ORDER BY id`);
+  await q(`CREATE VIEW ${DB}.net AS SELECT id, ${NET}(amt, id) AS n FROM ${DB}.orders`);
+  await q(`CREATE MATERIALIZED VIEW ${DB}.labels ENGINE = MergeTree ORDER BY id AS SELECT id, ${LABEL}(kind) AS l FROM ${DB}.orders`);
+}, 600_000);
+
+afterAll(async () => {
+  if (enabled) await cleanup();
+  await server?.stop();
+});
+
+describe.skipIf(!enabled)("import finds a function by its body (#3745)", () => {
+  test("a view, a materialized view and a column default using functions adopt them; an unused one is named with the importFunctions hint", async () => {
+    // The premise: the server keeps no call to the function.
+    const [view] = await q(`SELECT create_table_query AS ddl FROM system.tables WHERE database = '${DB}' AND name = 'net'`);
+    expect(String(view!.ddl)).not.toContain(NET);
+
+    const profile = {
+      url: endpoint.url,
+      databases: [DB],
+      ...(endpoint.user !== undefined ? { user: { env: "CH_USER" } } : {}),
+      ...(endpoint.password !== undefined ? { password: { env: "CH_PASSWORD" } } : {}),
+    };
+    const ir = await exportResources({
+      environment: "e2e",
+      config: { sql: { profiles: { e2e: profile } } } as never,
+      env: { CH_USER: endpoint.user, CH_PASSWORD: endpoint.password },
+    });
+    const names = ir.resources.map((r) => String(r.properties.name));
+    expect(names).toEqual(expect.arrayContaining(["orders", "net", "labels", TAX, NET, LABEL]));
+    expect(names).not.toContain(UNUSED);
+    expect(ir.warnings).toEqual(expect.arrayContaining([expect.stringMatching(new RegExp(`not imported, since no imported object uses (it|them): .*${UNUSED}.*importFunctions`))]));
+  });
+});

package/src/clickhouse/import/inlined.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "vitest";
+import { inlinedFunctions } from "./inlined";
+
+// What the server prints for each, as read from system.functions (#3745).
+const FUNCTIONS = [
+  { name: "tax", statement: "CREATE FUNCTION tax AS x -> (x * 0.2)" },
+  { name: "net", statement: "CREATE FUNCTION net AS (x, y) -> (tax(x) + if(y > 1, y, 0))" },
+  { name: "ident", statement: "CREATE FUNCTION ident AS x -> x" },
+  { name: "label", statement: "CREATE FUNCTION label AS s -> concat('[', lower(s), ']')" },
+];
+
+const found = (...statements: string[]) => inlinedFunctions(statements, FUNCTIONS);
+
+describe("a function found by its body in a stored definition (#3745)", () => {
+  test("a column DEFAULT holds the body with the argument in place of the parameter", () => {
+    expect(found("CREATE TABLE d.t\n(\n    `id` UInt64,\n    `amt` Float64 DEFAULT id * 0.2\n)\nENGINE = MergeTree\nORDER BY id")).toEqual(["tax"]);
+  });
+
+  test("a nested call is matched expanded, and so is the function it calls", () => {
+    expect(found("CREATE VIEW d.v\n(\n    `z` Float64\n)\nAS SELECT (amt * 0.2) + if(id > 1, id, 0) AS z\nFROM d.t")).toEqual(["tax", "net"]);
+  });
+
+  test("the server's parentheses around the body or an argument don't matter", () => {
+    expect(found("CREATE VIEW d.v AS SELECT id FROM d.t WHERE (id * 0.2) > 1")).toEqual(["tax"]);
+    expect(found("CREATE VIEW d.v AS SELECT (a + b) * 0.2 AS t FROM d.t")).toEqual(["tax"]);
+    expect(found("CREATE VIEW d.v AS SELECT concat('[', lower(name), ']') AS l FROM d.t")).toEqual(["label"]);
+  });
+
+  test("a parameter used twice must take the same argument twice", () => {
+    expect(found("CREATE VIEW d.v AS SELECT (a * 0.2) + if(b > 1, c, 0) AS z FROM d.t")).toEqual(["tax"]);
+  });
+
+  test("two parameters and an operator are enough, so such a body is found wherever that operator is", () => {
+    const scale = [{ name: "scale", statement: "CREATE FUNCTION scale AS (x, k) -> (x * k)" }];
+    expect(inlinedFunctions(["CREATE VIEW d.v AS SELECT price * qty AS total FROM d.t"], scale)).toEqual(["scale"]);
+    expect(inlinedFunctions(["CREATE VIEW d.v AS SELECT price + qty AS total FROM d.t"], scale)).toEqual([]);
+  });
+
+  test("a body that is only a parameter is never found, and nothing else is found where the body is absent", () => {
+    expect(found("CREATE VIEW d.v AS SELECT id FROM d.t")).toEqual([]);
+    expect(found("CREATE VIEW d.v AS SELECT id * 0.3 FROM d.t")).toEqual([]);
+  });
+
+  test("an argument never spans a comma or the next clause", () => {
+    expect(found("CREATE VIEW d.v AS SELECT a, 0.2 FROM d.t")).toEqual([]);
+    expect(found("CREATE VIEW d.v AS SELECT x FROM d.t WHERE 1 + if(y > 1, y, 0)")).toEqual([]);
+  });
+});

package/src/clickhouse/import/inlined.ts

@@ -0,0 +1,200 @@
+/**
+ * Finding a SQL user-defined function in what ClickHouse stored (#3745).
+ *
+ * ClickHouse does not keep a call to a SQL function in a view's query or a
+ * column's DEFAULT: it writes the function's body in place of the call, with
+ * the arguments substituted, and a nested call expanded the same way.
+ * `CREATE FUNCTION tax AS x -> (x * 0.2)` used as `tax(amt)` reads back as
+ * `amt * 0.2`. So an import can't look for the name; it looks for the body.
+ *
+ * Each function's body is expanded (a call to another function becomes that
+ * function's body), its parameters become wildcards, and the result is
+ * matched against the stored statement's tokens. Parentheses that only
+ * group are dropped on both sides, since the server adds or leaves them by
+ * precedence where the body lands. A wildcard matches one balanced
+ * expression, and a parameter used twice must match the same text twice.
+ *
+ * A function whose body is just a parameter (`x -> x`) leaves nothing to
+ * look for, so it is never found this way.
+ */
+
+import { isTrivia, tokenizeText, type Token } from "../tokens";
+import { unquote } from "../parser";
+
+/** One item of a pattern: a token's text, or the parameter at `arg`. */
+type Item = { lit: string } | { arg: number };
+
+/** A function's parameters and body, from `CREATE FUNCTION name AS (x, y) -> body`; undefined when it doesn't read that way. */
+export function functionLambda(statement: string): { params: string[]; body: Token[] } | undefined {
+  let tokens: Token[];
+  try {
+    tokens = tokenizeText(statement, 0).filter((t) => !isTrivia(t));
+  } catch {
+    return undefined;
+  }
+  const as = tokens.findIndex((t) => t.kind === "ident" && t.text.toUpperCase() === "AS");
+  const arrow = tokens.findIndex((t, i) => i > as && t.kind === "op" && t.text === "->");
+  if (as < 0 || arrow < 0) return undefined;
+  const params = tokens
+    .slice(as + 1, arrow)
+    .filter((t) => t.kind === "ident" || t.kind === "qident")
+    .map(nameOf);
+  const body = tokens.slice(arrow + 1);
+  while (body.length > 0 && body[body.length - 1]!.kind === "punct" && body[body.length - 1]!.text === ";") body.pop();
+  return { params, body };
+}
+
+const nameOf = (t: Token): string => (t.kind === "qident" ? unquote(t.text) : t.text);
+const isPunct = (t: Token | undefined, text: string): boolean => t?.kind === "punct" && t.text === text;
+const isName = (t: Token | undefined): boolean => t?.kind === "ident" || t?.kind === "qident";
+
+/** Words a `(` can follow that make it a grouping, not a call. */
+const GROUPING_AFTER = new Set(
+  ["AND", "OR", "NOT", "IS", "LIKE", "ILIKE", "BETWEEN", "WHEN", "THEN", "ELSE", "CASE", "SELECT", "WHERE", "PREWHERE", "HAVING", "FROM", "ON", "AS", "BY", "DEFAULT", "MATERIALIZED", "ALIAS", "EPHEMERAL", "TTL", "INTERVAL", "DISTINCT", "ALL"],
+);
+
+/** Words a wildcard never spans: they start the next clause or column attribute. */
+const CLAUSE = new Set(
+  ["SELECT", "FROM", "WHERE", "PREWHERE", "GROUP", "ORDER", "HAVING", "LIMIT", "AS", "ENGINE", "SETTINGS", "DEFAULT", "MATERIALIZED", "ALIAS", "EPHEMERAL", "CODEC", "TTL", "COMMENT", "JOIN", "ON", "USING", "UNION", "WITH"],
+);
+
+/** The tokens with grouping parentheses taken out; a call's parentheses stay. Trivia is assumed gone. */
+function ungroup(tokens: readonly Token[]): Token[] {
+  const out: Token[] = [];
+  const grouping: boolean[] = [];
+  tokens.forEach((t, i) => {
+    if (isPunct(t, "(")) {
+      const prev = tokens[i - 1];
+      const call = (isName(prev) && !(prev!.kind === "ident" && GROUPING_AFTER.has(prev!.text.toUpperCase()))) || isPunct(prev, ")");
+      grouping.push(!call);
+      if (call) out.push(t);
+    } else if (isPunct(t, ")")) {
+      if (grouping.pop() === false) out.push(t);
+    } else out.push(t);
+  });
+  return out;
+}
+
+/** The index past the `)` matching the `(` at `open`, and the arguments between, split at top-level commas. */
+function callArgs(tokens: readonly Token[], open: number): { args: Token[][]; end: number } | undefined {
+  const args: Token[][] = [[]];
+  let depth = 0;
+  for (let i = open + 1; i < tokens.length; i++) {
+    const t = tokens[i]!;
+    if (isPunct(t, "(")) depth++;
+    else if (isPunct(t, ")")) {
+      if (depth === 0) return { args: args.length === 1 && args[0]!.length === 0 ? [] : args, end: i + 1 };
+      depth--;
+    } else if (depth === 0 && isPunct(t, ",")) {
+      args.push([]);
+      continue;
+    }
+    args[args.length - 1]!.push(t);
+  }
+  return undefined;
+}
+
+/** A placeholder token for parameter `n`, which can't collide with anything a statement holds. */
+const placeholder = (n: number): Token => ({ kind: "ident", text: `\u0000${n}`, part: 0, start: 0, end: 0 });
+
+/**
+ * `tokens` with `params` replaced by their arguments' tokens and each call to
+ * a function in `lambdas` replaced by that function's body, recursively.
+ */
+function expand(tokens: readonly Token[], params: ReadonlyMap<string, Token[]>, lambdas: ReadonlyMap<string, { params: string[]; body: Token[] }>, seen: ReadonlySet<string>): Token[] {
+  const out: Token[] = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const t = tokens[i]!;
+    if (isName(t)) {
+      const name = nameOf(t);
+      const callee = lambdas.get(name);
+      if (callee && isPunct(tokens[i + 1], "(") && !seen.has(name)) {
+        const call = callArgs(tokens, i + 1);
+        if (call && call.args.length === callee.params.length) {
+          const bound = new Map(callee.params.map((p, n) => [p, expand(call.args[n]!, params, lambdas, seen)]));
+          out.push(...expand(callee.body, bound, lambdas, new Set([...seen, name])));
+          i = call.end - 1;
+          continue;
+        }
+      }
+      const arg = params.get(name);
+      // A parameter is a bare name: `x`, not the `x` in `t.x` or a call `x(...)`.
+      if (arg && !isPunct(tokens[i - 1], ".") && !isPunct(tokens[i + 1], "(")) {
+        out.push(...arg);
+        continue;
+      }
+    }
+    out.push(t);
+  }
+  return out;
+}
+
+/** What to look for: the function's expanded body, with its parameters as wildcards. Undefined when nothing but a parameter is left to match. */
+export function inlinedPattern(name: string, lambdas: ReadonlyMap<string, { params: string[]; body: Token[] }>): Item[] | undefined {
+  const own = lambdas.get(name);
+  if (!own) return undefined;
+  const params = new Map(own.params.map((p, n) => [p, [placeholder(n)]]));
+  const tokens = ungroup(expand(own.body, params, lambdas, new Set([name])));
+  const items: Item[] = tokens.map((t) => (t.text.startsWith("\u0000") ? { arg: Number(t.text.slice(1)) } : { lit: t.text }));
+  return items.some((i) => "lit" in i) ? items : undefined;
+}
+
+/** A budget on matching steps per statement, so a pathological statement can't stall an import. */
+const STEP_LIMIT = 200_000;
+
+/** Whether `pattern` appears in `statement`'s tokens. */
+export function containsInlined(statement: string, pattern: readonly Item[]): boolean {
+  let raw: Token[];
+  try {
+    raw = tokenizeText(statement, 0).filter((t) => !isTrivia(t));
+  } catch {
+    return false;
+  }
+  const text = ungroup(raw).map((t) => t.text);
+  const lits = pattern.flatMap((i) => ("lit" in i ? [i.lit] : []));
+  const present = new Set(text);
+  if (!lits.every((l) => present.has(l))) return false;
+  let steps = 0;
+  const match = (p: number, at: number, bound: Map<number, string[]>): boolean => {
+    if (++steps > STEP_LIMIT) return false;
+    if (p === pattern.length) return true;
+    const item = pattern[p]!;
+    if ("lit" in item) return text[at] === item.lit && match(p + 1, at + 1, bound);
+    const known = bound.get(item.arg);
+    if (known) return known.every((s, k) => text[at + k] === s) && match(p + 1, at + known.length, bound);
+    // One balanced expression: never past a top-level comma, an unmatched `)`, or the next clause.
+    let depth = 0;
+    for (let end = at; end < text.length; end++) {
+      const s = text[end]!;
+      if (depth === 0 && (s === "," || s === ";" || s === ")" || CLAUSE.has(s.toUpperCase()))) return false;
+      if (s === "(") depth++;
+      else if (s === ")") depth--;
+      if (depth > 0) continue;
+      bound.set(item.arg, text.slice(at, end + 1));
+      if (match(p + 1, end + 1, bound)) return true;
+      bound.delete(item.arg);
+    }
+    return false;
+  };
+  for (let at = 0; at < text.length; at++) if (match(0, at, new Map())) return true;
+  return false;
+}
+
+/**
+ * The functions among `functions` whose bodies appear inlined in any of
+ * `statements`. A function is matched with the others' bodies expanded into
+ * its own, as the server does.
+ */
+export function inlinedFunctions(statements: readonly string[], functions: ReadonlyArray<{ name: string; statement: string }>): string[] {
+  const lambdas = new Map<string, { params: string[]; body: Token[] }>();
+  for (const f of functions) {
+    const l = functionLambda(f.statement);
+    if (l) lambdas.set(f.name, l);
+  }
+  const out: string[] = [];
+  for (const f of functions) {
+    const pattern = inlinedPattern(f.name, lambdas);
+    if (pattern && statements.some((s) => containsInlined(s, pattern))) out.push(f.name);
+  }
+  return out;
+}

package/src/clickhouse/import/live-export.ts

@@ -17,9 +17,11 @@
  *   `goose_db_version`) is left out with a warning (#3676), as on Postgres.
  * - A SQL user-defined function belongs to no database, and every project's
  *   functions sit side by side on a server (#3718). Without a selector, an
- *   import adopts only the functions the imported objects call (and those
+ *   import adopts only the functions the imported objects use (and those
  *   functions call), and the ones `sql.profiles.<env>.importFunctions` names;
- *   a warning names the rest. A function carries no comment, so `owned` does
+ *   a warning names the rest. ClickHouse stores a call as the function's body
+ *   (#3745), so a use is found by that body (`./inlined.ts`) as well as by
+ *   the name. A function carries no comment, so `owned` does
  *   not apply to it.
  */
 
@@ -32,6 +34,7 @@ import { CLICKHOUSE_ENTITY_TYPES } from "../entities";
 import { isTrivia, tokenizeText } from "../tokens";
 import { unquote } from "../parser";
 import type { LiveObject } from "../live/catalog";
+import { inlinedFunctions } from "./inlined";
 
 /** The functions among `names` a statement calls: a name followed by `(`. */
 export function calledFunctions(ddl: string, names: ReadonlySet<string>): string[] {
@@ -52,13 +55,15 @@ const named = (patterns: readonly string[], name: string) => patterns.some((p) =
 
 /**
  * The functions an import adopts (#3718): those the objects call, those
- * `patterns` name, and the functions those call in turn; and the rest.
+ * whose bodies the objects hold in place of a call (#3745, `./inlined.ts`),
+ * those `patterns` name, and the functions those call in turn; and the rest.
  */
 export function scopedFunctions(objects: readonly LiveObject[], functions: readonly LiveObject[], patterns: readonly string[] = []): { adopted: LiveObject[]; skipped: string[] } {
   const byName = new Map(functions.map((f) => [f.name, f]));
   const names = new Set(byName.keys());
   const adopted = new Set<string>(functions.filter((f) => named(patterns, f.name)).map((f) => f.name));
   for (const o of objects) for (const n of calledFunctions(o.statement, names)) adopted.add(n);
+  for (const n of inlinedFunctions(objects.map((o) => o.statement), functions)) adopted.add(n);
   const queue = [...adopted];
   while (queue.length > 0) {
     for (const n of calledFunctions(byName.get(queue.pop()!)!.statement, names)) {
@@ -99,7 +104,7 @@ export async function exportResources(options: ExportOptions): Promise<ExportedT
     selected.push(...adopted);
     if (skipped.length > 0) {
       warnings.push(
-        `${skipped.length} SQL function${skipped.length === 1 ? "" : "s"} on the server ${skipped.length === 1 ? "is" : "are"} not imported, since no imported object calls ${skipped.length === 1 ? "it" : "them"}: ${skipped.join(", ")}. Name ${skipped.length === 1 ? "it" : "them"} in sql.profiles.${options.environment}.importFunctions to import ${skipped.length === 1 ? "it" : "them"}.`,
+        `${skipped.length} SQL function${skipped.length === 1 ? "" : "s"} on the server ${skipped.length === 1 ? "is" : "are"} not imported, since no imported object uses ${skipped.length === 1 ? "it" : "them"}: ${skipped.join(", ")}. Name ${skipped.length === 1 ? "it" : "them"} in sql.profiles.${options.environment}.importFunctions to import ${skipped.length === 1 ? "it" : "them"}.`,
       );
     }
   }

package/src/config.ts

@@ -106,10 +106,12 @@ export const sqlProfileSchema = z.strictObject({
   defaultDatabase: z.string().optional(),
   /**
    * ClickHouse import (#3718): the SQL user-defined functions `chant import
-   * --from <env>` adopts besides those the imported objects call, by name, or
+   * --from <env>` adopts besides those the imported objects use, by name, or
    * by prefix with a trailing `*` (`shop_*`). A function belongs to no
    * database, so without this only the functions the imported tables, views
-   * and dictionaries call (and the functions those call) are imported.
+   * and dictionaries use (and the functions those call) are imported. A use
+   * is found by name or, since ClickHouse stores a call as the function's
+   * body, by that body (#3745).
    */
   importFunctions: z.array(z.string()).optional(),
   /**