@quark-fw/clisma 0.1.26 → 0.1.28

package/dist/src/ddl.js

@@ -0,0 +1,52 @@
+// src/ddl.ts
+import { escapeId } from "./escape-id.js";
+import { buildIndexSQL } from "./build-index-sql.js";
+import { quoteString, renderEngine, renderKeyList, renderKeyPart, } from "./ddl-shared.js";
+// список для `SETTINGS` / `MODIFY SETTING`: числа как есть, строки в кавычках
+export function renderSettings(settings) {
+    return Object.entries(settings)
+        .map(([key, value]) => typeof value === "number"
+        ? `${key} = ${value}`
+        : `${key} = ${quoteString(value)}`)
+        .join(", ");
+}
+export function buildColumnSQL(name, col) {
+    const parts = [escapeId(name), col.clickhouseType];
+    if (col.default)
+        parts.push(`${col.default.kind} ${col.default.expr}`);
+    if (col.codec)
+        parts.push(`CODEC(${col.codec})`);
+    if (col.comment)
+        parts.push(`COMMENT ${quoteString(col.comment)}`);
+    return parts.join(" ");
+}
+export function buildCreateTableSQL(database, tableName, table) {
+    const body = [
+        ...Object.entries(table.columns).map(([name, col]) => buildColumnSQL(name, col)),
+        ...(table.indexes ?? []).map(buildIndexSQL),
+    ].join(",\n");
+    const clauses = [`ENGINE = ${renderEngine(table)}`];
+    if (table.partitionBy) {
+        clauses.push(`PARTITION BY ${renderKeyPart(table.partitionBy)}`);
+    }
+    if (table.primaryKey) {
+        clauses.push(`PRIMARY KEY ${renderKeyList(table.primaryKey)}`);
+    }
+    clauses.push(`ORDER BY ${renderKeyList(table.orderBy)}`);
+    if (table.sampleBy)
+        clauses.push(`SAMPLE BY ${renderKeyPart(table.sampleBy)}`);
+    if (table.ttl)
+        clauses.push(`TTL ${table.ttl}`);
+    if (table.settings && Object.keys(table.settings).length) {
+        clauses.push(`SETTINGS ${renderSettings(table.settings)}`);
+    }
+    if (table.comment)
+        clauses.push(`COMMENT ${quoteString(table.comment)}`);
+    return `
+    CREATE TABLE IF NOT EXISTS ${escapeId(database)}.${escapeId(tableName)}
+    (
+      ${body}
+    )
+    ${clauses.join("\n    ")}
+  `.trim();
+}

package/dist/src/dictionary.d.ts

@@ -0,0 +1,26 @@
+import type { Column } from "./column.js";
+export type DictionaryCredentials = {
+    user: string;
+    password?: string;
+};
+export type DictionarySource = ({
+    query: string;
+} | {
+    table: string;
+    database?: string;
+    where?: string;
+}) & Partial<DictionaryCredentials>;
+export type DictionaryLayout = "flat" | "hashed" | "sparse_hashed" | "hashed_array" | "complex_key_hashed";
+export type DictionaryDefinition<TKey extends Record<string, Column<unknown>>, TAttributes extends Record<string, Column<unknown>>> = {
+    key: TKey;
+    attributes: TAttributes;
+    source: DictionarySource;
+    layout: DictionaryLayout;
+    lifetime: number | {
+        min: number;
+        max: number;
+    };
+    comment?: string;
+};
+export type AnyDictionary = DictionaryDefinition<Record<string, Column<unknown>>, Record<string, Column<unknown>>>;
+export declare function dictionary<TKey extends Record<string, Column<unknown>>, TAttributes extends Record<string, Column<unknown>>>(def: DictionaryDefinition<TKey, TAttributes>): DictionaryDefinition<TKey, TAttributes>;

package/dist/src/dictionary.js

@@ -0,0 +1,7 @@
+// src/dictionary.ts
+export function dictionary(def) {
+    if (Object.keys(def.key).length === 0) {
+        throw new Error("Dictionary requires at least one key column");
+    }
+    return def;
+}

package/dist/src/engine.d.ts

@@ -0,0 +1,16 @@
+export type EngineSpec = {
+    family: "MergeTree" | "ReplacingMergeTree" | "CollapsingMergeTree" | "VersionedCollapsingMergeTree" | "SummingMergeTree" | "AggregatingMergeTree";
+    args: string[];
+    collapsing?: {
+        sign: string;
+        version?: string;
+    };
+};
+export declare const engine: {
+    mergeTree: () => EngineSpec;
+    replacingMergeTree: (version?: string) => EngineSpec;
+    collapsingMergeTree: (sign: string) => EngineSpec;
+    versionedCollapsingMergeTree: (sign: string, version: string) => EngineSpec;
+    summingMergeTree: (columns?: string[]) => EngineSpec;
+    aggregatingMergeTree: () => EngineSpec;
+};

package/dist/src/engine.js

@@ -0,0 +1,26 @@
+// src/engine.ts
+export const engine = {
+    mergeTree: () => ({ family: "MergeTree", args: [] }),
+    replacingMergeTree: (version) => ({
+        family: "ReplacingMergeTree",
+        args: version ? [version] : [],
+    }),
+    collapsingMergeTree: (sign) => ({
+        family: "CollapsingMergeTree",
+        args: [sign],
+        collapsing: { sign },
+    }),
+    versionedCollapsingMergeTree: (sign, version) => ({
+        family: "VersionedCollapsingMergeTree",
+        args: [sign, version],
+        collapsing: { sign, version },
+    }),
+    summingMergeTree: (columns = []) => ({
+        family: "SummingMergeTree",
+        args: columns.length ? [`(${columns.join(", ")})`] : [],
+    }),
+    aggregatingMergeTree: () => ({
+        family: "AggregatingMergeTree",
+        args: [],
+    }),
+};

package/dist/src/ensure-dictionaries-on-nodes.d.ts

@@ -0,0 +1,3 @@
+import type { AnyDictionary, DictionaryCredentials } from "./dictionary.js";
+import type { DdlNode, DdlStatement } from "./ensure-tables-on-nodes.js";
+export declare function ensureDictionariesOnNodes(nodes: DdlNode[], database: string, dictionaries: Record<string, AnyDictionary>, credentials?: DictionaryCredentials, mode?: "create" | "replace"): Promise<DdlStatement[]>;

package/dist/src/ensure-dictionaries-on-nodes.js

@@ -0,0 +1,15 @@
+// src/ensure-dictionaries-on-nodes.ts
+import { buildCreateDictionarySQL } from "./build-create-dictionary-query.js";
+// Словарь не реплицируется — это локальный кэш каждой ноды над её же
+// данными, поэтому он создаётся из схемы на каждой ноде отдельно.
+export async function ensureDictionariesOnNodes(nodes, database, dictionaries, credentials, mode = "create") {
+    const executed = [];
+    for (const node of nodes) {
+        for (const name in dictionaries) {
+            const sql = buildCreateDictionarySQL(database, name, dictionaries[name], credentials, mode);
+            await node.client.command({ query: sql });
+            executed.push({ node: node.url, sql });
+        }
+    }
+    return executed;
+}

package/dist/src/ensure-tables-on-nodes.d.ts

@@ -0,0 +1,11 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { AnyTable } from "./table.js";
+export type DdlNode = {
+    url: string;
+    client: ClickHouseClient;
+};
+export type DdlStatement = {
+    node: string;
+    sql: string;
+};
+export declare function ensureTablesOnNodes(nodes: DdlNode[], database: string, tables: Record<string, AnyTable>): Promise<DdlStatement[]>;

package/dist/src/ensure-tables-on-nodes.js

@@ -0,0 +1,39 @@
+// src/ensure-tables-on-nodes.ts
+import { buildCreateTableSQL } from "./ddl.js";
+import { escapeId } from "./escape-id.js";
+async function tableExists(client, database, tableName) {
+    const result = await client.query({
+        query: `EXISTS TABLE ${escapeId(database)}.${escapeId(tableName)}`,
+        format: "JSONEachRow",
+    });
+    const rows = await result.json();
+    return Number(rows[0]?.result) === 1;
+}
+// Первая нода — источник истины: на ней таблица создаётся из схемы, а на
+// остальные копируется её SHOW CREATE TABLE. Копия, а не повторный рендер —
+// потому что Keeper сверяет метаданные реплик побайтово (порядок колонок,
+// дефолты), и любое расхождение рендера оставило бы реплику вне набора.
+export async function ensureTablesOnNodes(nodes, database, tables) {
+    const [primary, ...secondaries] = nodes;
+    const executed = [];
+    for (const tableName in tables) {
+        const createSQL = buildCreateTableSQL(database, tableName, tables[tableName]);
+        await primary.client.command({ query: createSQL });
+        executed.push({ node: primary.url, sql: createSQL });
+    }
+    for (const node of secondaries) {
+        for (const tableName in tables) {
+            if (await tableExists(node.client, database, tableName))
+                continue;
+            const shown = await primary.client.query({
+                query: `SHOW CREATE TABLE ${escapeId(database)}.${escapeId(tableName)}`,
+                format: "JSONEachRow",
+            });
+            const [{ statement }] = await shown.json();
+            const copySQL = statement.replace(/^CREATE TABLE /, "CREATE TABLE IF NOT EXISTS ");
+            await node.client.command({ query: copySQL });
+            executed.push({ node: node.url, sql: copySQL });
+        }
+    }
+    return executed;
+}

package/dist/src/escape-id.d.ts

@@ -0,0 +1 @@
+export declare function escapeId(name: string): string;

package/dist/src/escape-id.js

@@ -0,0 +1,4 @@
+// src/escape-id.ts
+export function escapeId(name) {
+    return "`" + name.replace(/\\/g, "\\\\").replace(/`/g, "\\`") + "`";
+}

package/dist/src/expr.d.ts

@@ -0,0 +1,5 @@
+export type Expr = {
+    readonly __expr: string;
+};
+export type KeyPart = string | Expr;
+export declare function expr(sql: string): Expr;

package/dist/src/expr.js

@@ -0,0 +1,4 @@
+// src/expr.ts
+export function expr(sql) {
+    return { __expr: sql };
+}

package/dist/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./column.js";
+export * from "./expr.js";
+export * from "./engine.js";
+export * from "./table.js";
+export * from "./dictionary.js";
+export * from "./schema.js";
+export * from "./client.js";
+export * from "./where.js";
+export * from "./sql.js";
+export * from "./table-client.js";
+export * from "./rows.js";
+export * from "./migrate.js";
+export * from "./ddl.js";
+export * from "./migration-error.js";
+export * from "./build-create-dictionary-query.js";
+export type { QueryOptions, QueryJsonResult, QuerySettings } from "./query.js";
+export type { DdlNode, DdlStatement } from "./ensure-tables-on-nodes.js";

package/dist/src/index.js

@@ -0,0 +1,15 @@
+export * from "./column.js";
+export * from "./expr.js";
+export * from "./engine.js";
+export * from "./table.js";
+export * from "./dictionary.js";
+export * from "./schema.js";
+export * from "./client.js";
+export * from "./where.js";
+export * from "./sql.js";
+export * from "./table-client.js";
+export * from "./rows.js";
+export * from "./migrate.js";
+export * from "./ddl.js";
+export * from "./migration-error.js";
+export * from "./build-create-dictionary-query.js";

package/dist/src/migrate.d.ts

@@ -0,0 +1,14 @@
+import { AnyTable } from "./table.js";
+export type DbColumn = {
+    table: string;
+    name: string;
+    type: string;
+};
+export type DbTableSettings = Record<string, Record<string, string>>;
+export type MigrationPlan = {
+    statements: string[];
+    warnings: string[];
+};
+export declare function parseEngineSettings(engineFull: string): Record<string, string>;
+export declare function buildMigrationPlan(database: string, tables: Record<string, AnyTable>, existing: DbColumn[]): MigrationPlan;
+export declare function buildSettingsPlan(database: string, tables: Record<string, AnyTable>, existingSettings: DbTableSettings): string[];

package/dist/src/migrate.js

@@ -0,0 +1,91 @@
+// src/migrate.ts
+import { buildColumnSQL, buildCreateTableSQL, renderSettings } from "./ddl.js";
+import { escapeId } from "./escape-id.js";
+import { keyColumns } from "./ddl-shared.js";
+// `SETTINGS a = 1, b = 'x'` из хвоста `system.tables.engine_full`
+export function parseEngineSettings(engineFull) {
+    const out = {};
+    const at = engineFull.lastIndexOf(" SETTINGS ");
+    if (at === -1)
+        return out;
+    const re = /(\w+)\s*=\s*('(?:[^'\\]|\\.)*'|[^,]+)/g;
+    for (const m of engineFull.slice(at + " SETTINGS ".length).matchAll(re)) {
+        const raw = m[2].trim();
+        out[m[1]] = raw.startsWith("'")
+            ? raw.slice(1, -1).replace(/\\(.)/g, "$1")
+            : raw;
+    }
+    return out;
+}
+export function buildMigrationPlan(database, tables, existing) {
+    const statements = [];
+    const warnings = [];
+    const dbTables = new Map();
+    for (const col of existing) {
+        let cols = dbTables.get(col.table);
+        if (!cols) {
+            cols = new Map();
+            dbTables.set(col.table, cols);
+        }
+        cols.set(col.name, col.type);
+    }
+    for (const tableName in tables) {
+        const def = tables[tableName];
+        const dbCols = dbTables.get(tableName);
+        if (!dbCols) {
+            statements.push(buildCreateTableSQL(database, tableName, def));
+            continue;
+        }
+        const tableRef = `${escapeId(database)}.${escapeId(tableName)}`;
+        const keys = keyColumns([...def.orderBy, ...(def.primaryKey ?? [])]);
+        for (const colName in def.columns) {
+            const col = def.columns[colName];
+            const wanted = col.clickhouseType;
+            const actual = dbCols.get(colName);
+            if (actual === undefined) {
+                statements.push(`ALTER TABLE ${tableRef} ADD COLUMN ${buildColumnSQL(colName, col)}`);
+            }
+            else if (actual !== wanted) {
+                // ключевую колонку сервер менять не даст; лучше внятная ошибка
+                // до выполнения плана, чем упавшая посередине миграция
+                if (keys.includes(colName)) {
+                    throw new Error(`Column "${colName}" of ${database}.${tableName} is part of the ` +
+                        `sorting key and cannot change type (${actual} → ${wanted}); ` +
+                        `recreate the table instead`);
+                }
+                statements.push(`ALTER TABLE ${tableRef} MODIFY COLUMN ${buildColumnSQL(colName, col)}`);
+            }
+        }
+        for (const dbColName of dbCols.keys()) {
+            if (!(dbColName in def.columns)) {
+                warnings.push(`Column "${dbColName}" exists in ${database}.${tableName} ` +
+                    `but not in the schema — not dropped, remove it manually if unneeded`);
+            }
+        }
+    }
+    return { statements, warnings };
+}
+// Настройки таблицы — локальные метаданные каждой ноды: MODIFY SETTING не
+// реплицируется (в отличие от ADD/MODIFY COLUMN), поэтому план настроек
+// строится и выполняется на каждой ноде по её `system.tables`. Только
+// объявленные в схеме настройки и только существующие на ноде таблицы —
+// новые получат их из CREATE (или из SHOW CREATE копии). Правка метаданных,
+// данные не переписываются.
+export function buildSettingsPlan(database, tables, existingSettings) {
+    const statements = [];
+    for (const tableName in tables) {
+        const declared = tables[tableName].settings;
+        const actual = existingSettings[tableName];
+        if (!declared || !actual)
+            continue;
+        const changed = {};
+        for (const [key, value] of Object.entries(declared)) {
+            if (actual[key] !== String(value))
+                changed[key] = value;
+        }
+        if (Object.keys(changed).length) {
+            statements.push(`ALTER TABLE ${escapeId(database)}.${escapeId(tableName)} MODIFY SETTING ${renderSettings(changed)}`);
+        }
+    }
+    return statements;
+}

package/dist/src/migration-error.d.ts

@@ -0,0 +1,10 @@
+import type { DdlStatement } from "./ensure-tables-on-nodes.js";
+export declare class MigrationError extends Error {
+    readonly executed: DdlStatement[];
+    readonly failed?: DdlStatement;
+    constructor(args: {
+        executed: DdlStatement[];
+        failed?: DdlStatement;
+        cause: unknown;
+    });
+}

package/dist/src/migration-error.js

@@ -0,0 +1,24 @@
+// src/migration-error.ts
+// DDL в ClickHouse не транзакционен: упавший посередине $migrate оставляет
+// выполненную часть на нодах. Без списка выполненного вызывающий не знает,
+// что уже применено, поэтому ошибка несёт его вместе с упавшим оператором.
+export class MigrationError extends Error {
+    // успешно выполненные до сбоя операторы, в порядке выполнения
+    executed;
+    // упавший оператор; нет, если сбой внутри докладки таблиц/словарей на
+    // ноды — тогда их выполненная часть видна только по самим нодам
+    failed;
+    constructor(args) {
+        const reason = args.cause instanceof Error
+            ? args.cause.message
+            : String(args.cause);
+        super(`$migrate failed after ${args.executed.length} statement(s)` +
+            (args.failed
+                ? ` on ${args.failed.node}: ${args.failed.sql}`
+                : "") +
+            `\n${reason}`, { cause: args.cause });
+        this.name = "MigrationError";
+        this.executed = args.executed;
+        this.failed = args.failed;
+    }
+}

package/dist/src/query.d.ts

@@ -0,0 +1,26 @@
+import type { ClickHouseClient } from "@clickhouse/client";
+import type { AnyColumns } from "./table.js";
+export type QuerySettings = Record<string, string | number | boolean>;
+export type QueryOptions = {
+    params?: Record<string, unknown>;
+    settings?: QuerySettings;
+    columns?: AnyColumns;
+};
+export type QueryJsonResult<TRow, TTotals = TRow> = {
+    data: TRow[];
+    totals?: TTotals;
+    rows: number;
+    rows_before_limit_at_least?: number;
+    meta: {
+        name: string;
+        type: string;
+    }[];
+    statistics: {
+        elapsed: number;
+        rows_read: number;
+        bytes_read: number;
+    };
+};
+export declare function runQuery<TRow>(client: ClickHouseClient, sql: string, options?: QueryOptions): Promise<TRow[]>;
+export declare function runQueryJson<TRow, TTotals = TRow>(client: ClickHouseClient, sql: string, options?: QueryOptions): Promise<QueryJsonResult<TRow, TTotals>>;
+export declare function runCommand(client: ClickHouseClient, sql: string, options?: Omit<QueryOptions, "columns">): Promise<void>;

package/dist/src/query.js

@@ -0,0 +1,60 @@
+// src/query.ts
+// Сырые запросы поверх @clickhouse/client: агрегаты, GROUP BY и DDL не
+// выражаются Prisma-синтаксисом, а второй клиент в приложении — дубль
+// соединения и настроек.
+import { deserializeRows } from "./rows.js";
+// те же настройки, что у findMany: ISO-даты без таймзонной неоднозначности и
+// 64-битные целые строками, чтобы BigInt() был без потерь
+const WIRE_SETTINGS = {
+    date_time_output_format: "iso",
+    output_format_json_quote_64bit_integers: 1,
+};
+function serializeParams(params = {}) {
+    const out = {};
+    for (const key in params) {
+        const value = params[key];
+        out[key] =
+            value instanceof Date ? Math.floor(value.getTime() / 1000) : value;
+    }
+    return out;
+}
+export async function runQuery(client, sql, options = {}) {
+    const result = await client.query({
+        query: sql,
+        query_params: serializeParams(options.params),
+        format: "JSONEachRow",
+        clickhouse_settings: { ...WIRE_SETTINGS, ...options.settings },
+    });
+    const rows = await result.json();
+    return options.columns
+        ? deserializeRows(rows, options.columns)
+        : rows;
+}
+// FORMAT JSON нужен, когда важны totals (WITH TOTALS), точный
+// rows_before_limit_at_least и статистика чтения — JSONEachRow их не отдаёт
+export async function runQueryJson(client, sql, options = {}) {
+    const result = await client.query({
+        query: sql,
+        query_params: serializeParams(options.params),
+        format: "JSON",
+        clickhouse_settings: { ...WIRE_SETTINGS, ...options.settings },
+    });
+    // у FORMAT JSON клиент типизирует поля как необязательные; сервер отдаёт их всегда
+    const body = (await result.json());
+    if (!options.columns)
+        return body;
+    return {
+        ...body,
+        data: deserializeRows(body.data, options.columns),
+        totals: body.totals
+            ? deserializeRows([body.totals], options.columns)[0]
+            : undefined,
+    };
+}
+export async function runCommand(client, sql, options = {}) {
+    await client.command({
+        query: sql,
+        query_params: serializeParams(options.params),
+        clickhouse_settings: options.settings,
+    });
+}

package/dist/src/rows.d.ts

@@ -0,0 +1,2 @@
+import { AnyColumns } from "./table.js";
+export declare function deserializeRows<T>(rows: Record<string, unknown>[], columns: AnyColumns): T[];

package/dist/src/rows.js

@@ -0,0 +1,45 @@
+// src/rows.ts
+const BIGINT_TYPES = new Set([
+    "UInt64",
+    "Int64",
+    "UInt128",
+    "Int128",
+    "UInt256",
+    "Int256",
+]);
+function convertValue(value, chType) {
+    if (value === null || value === undefined)
+        return value;
+    const nullable = /^Nullable\((.+)\)$/.exec(chType);
+    if (nullable)
+        return convertValue(value, nullable[1]);
+    // LowCardinality — способ хранения, на значение не влияет
+    const lowCardinality = /^LowCardinality\((.+)\)$/.exec(chType);
+    if (lowCardinality)
+        return convertValue(value, lowCardinality[1]);
+    const array = /^Array\((.+)\)$/.exec(chType);
+    if (array) {
+        return value.map((v) => convertValue(v, array[1]));
+    }
+    if (BIGINT_TYPES.has(chType))
+        return BigInt(value);
+    // Float может прийти строкой (inf/nan или quote_64bit_integers у Float64
+    // на старых серверах) — приводим к number; Decimal, Enum, IPv4/6 и Map
+    // приходят уже в нужном виде
+    if (chType.startsWith("Float"))
+        return Number(value);
+    if (chType.startsWith("DateTime") || chType.startsWith("Date")) {
+        return new Date(value);
+    }
+    return value;
+}
+export function deserializeRows(rows, columns) {
+    return rows.map((row) => {
+        const out = {};
+        for (const k in row) {
+            const col = columns[k];
+            out[k] = col ? convertValue(row[k], col.clickhouseType) : row[k];
+        }
+        return out;
+    });
+}

package/dist/src/schema.d.ts

@@ -0,0 +1,8 @@
+import { AnyTable } from "./table.js";
+import type { AnyDictionary } from "./dictionary.js";
+export type ClismaSchema<TTables extends Record<string, AnyTable>, TDictionaries extends Record<string, AnyDictionary> = Record<string, never>> = {
+    database?: string;
+    tables: TTables;
+    dictionaries?: TDictionaries;
+};
+export declare function createClisma<TTables extends Record<string, AnyTable>, TDictionaries extends Record<string, AnyDictionary> = Record<string, never>>(schema: ClismaSchema<TTables, TDictionaries>): ClismaSchema<TTables, TDictionaries>;

package/dist/src/schema.js

@@ -0,0 +1,4 @@
+// src/schema.ts
+export function createClisma(schema) {
+    return schema;
+}

package/dist/src/sql-shared.d.ts

@@ -0,0 +1,33 @@
+import { AnyColumns, AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+export type SQLBuildResult = {
+    sql: string;
+    params: Record<string, unknown>;
+};
+export type OrderByInput<T> = {
+    [K in keyof T]?: "asc" | "desc";
+};
+export type FindManyArgs<T> = {
+    where?: WhereInput<T>;
+    select?: {
+        [K in keyof T]?: boolean;
+    };
+    orderBy?: OrderByInput<T> | OrderByInput<T>[];
+    take?: number;
+    skip?: number;
+    final?: boolean;
+    settings?: Record<string, unknown>;
+};
+export { escapeId } from "./escape-id.js";
+export declare const NO_LIMIT = "18446744073709551615";
+export declare function createBuildContext(tableName: string, columns: AnyColumns): {
+    params: Record<string, unknown>;
+    colRef: (key: string) => string;
+    baseType: (key: string) => string;
+    addParam: (value: unknown, type: string) => string;
+    whereSQL: (where: Record<string, unknown>) => string;
+};
+export declare function tableRef(database: string, tableName: string, table: AnyTable, final?: boolean): string;
+export declare function countExpr(table: AnyTable): string;
+export declare function checkPagination(name: string, value: number): void;
+export declare function validateUpdateData(table: AnyTable, tableName: string, data: Record<string, unknown>): string[];