@datatruck/cli 0.22.2 → 0.23.1

package/Task/MysqlDumpTask.d.ts

@@ -7,6 +7,10 @@ export type MysqlDumpTaskConfigType = {
      */
     dataFormat?: "csv" | "sql";
     csvSharedPath?: string;
+    /**
+     * @default 1
+     */
+    concurrency?: number;
 } & SqlDumpTaskConfigType;
 export declare const mysqlDumpTaskDefinition: import("json-schema").JSONSchema7;
 export declare class MysqlDumpTask extends TaskAbstract<MysqlDumpTaskConfigType> {

package/Task/MysqlDumpTask.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDumpTask = exports.mysqlDumpTaskDefinition = exports.mysqlDumpTaskName = void 0;
 const AppError_1 = require("../Error/AppError");
+const async_1 = require("../utils/async");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
@@ -16,6 +17,7 @@ const path_1 = require("path");
 exports.mysqlDumpTaskName = "mysql-dump";
 exports.mysqlDumpTaskDefinition = (0, SqlDumpTaskAbstract_1.sqlDumpTaskDefinition)({
     dataFormat: { enum: ["csv", "sql"] },
+    concurrency: { type: "integer", minimum: 1 },
     csvSharedPath: { type: "string" },
 });
 const suffix = {
@@ -27,85 +29,92 @@ const suffix = {
 };
 class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
     async onBackup(data) {
-        const sql = (0, mysql_1.createMysqlCli)({
+        const sql = await (0, mysql_1.createMysqlCli)({
             ...this.config,
             verbose: data.options.verbose,
         });
         const tableNames = await sql.fetchTableNames(this.config.database, this.config.includeTables, this.config.excludeTables);
         const outputPath = data.package.path;
         (0, assert_1.ok)(typeof outputPath === "string");
+        const concurrency = this.config.concurrency ?? 4;
         const dataFormat = this.config.dataFormat ?? "sql";
         await (0, promises_1.mkdir)(outputPath, { recursive: true });
         const sharedDir = dataFormat === "csv"
             ? await sql.initSharedDir(this.config.csvSharedPath)
             : undefined;
         if (this.config.oneFileByTable || sharedDir) {
-            let current = 0;
-            for (const tableName of tableNames) {
-                await data.onProgress({
+            await (0, async_1.runParallel)({
+                items: tableNames,
+                concurrency,
+                onChange: async ({ processed: proccesed, buffer }) => await data.onProgress({
                     relative: {
-                        description: "Exporting",
-                        payload: tableName,
+                        description: buffer.size > 1 ? `Exporting (${buffer.size})` : "Exporting",
+                        payload: [...buffer.keys()].join(", "),
                     },
                     absolute: {
                         total: tableNames.length,
-                        current,
-                        percent: (0, math_1.progressPercent)(tableNames.length, current),
+                        current: proccesed,
+                        percent: (0, math_1.progressPercent)(tableNames.length, proccesed),
                     },
-                });
-                if (sharedDir) {
-                    const tableSharedPath = (0, path_1.join)(sharedDir, `tmp-dtt-backup-${data.snapshot.id.slice(0, 8)}-${tableName}`);
-                    if (data.options.verbose) {
-                        (0, cli_1.logExec)("mkdir", ["-p", tableSharedPath]);
-                        (0, cli_1.logExec)("chmod", ["777", tableSharedPath]);
+                }),
+                onItem: async ({ item: tableName, index, controller }) => {
+                    if (sharedDir) {
+                        const tableSharedPath = (0, path_1.join)(sharedDir, `tmp-dtt-backup-${data.snapshot.id.slice(0, 8)}-${tableName}`);
+                        if (data.options.verbose) {
+                            (0, cli_1.logExec)("mkdir", ["-p", tableSharedPath]);
+                            (0, cli_1.logExec)("chmod", ["777", tableSharedPath]);
+                        }
+                        await (0, promises_1.mkdir)(tableSharedPath, { recursive: true });
+                        try {
+                            await (0, promises_1.chmod)(tableSharedPath, 0o777);
+                            await sql.csvDump({
+                                sharedPath: tableSharedPath,
+                                items: [tableName],
+                                database: this.config.database,
+                                onSpawn: (p) => (controller.stop = () => p.kill()),
+                            });
+                            const files = await (0, promises_1.readdir)(tableSharedPath);
+                            const schemaFile = `${tableName}.sql`;
+                            const dataFile = `${tableName}.txt`;
+                            const successCsvDump = files.length === 2 &&
+                                files.every((file) => file === schemaFile || file === dataFile);
+                            if (!successCsvDump)
+                                throw new AppError_1.AppError(`Invalid csv dump files: ${files.join(", ")}`);
+                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, schemaFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableSchema}`));
+                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, dataFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableData}`));
+                        }
+                        finally {
+                            await (0, promises_1.rm)(tableSharedPath, { recursive: true });
+                        }
                     }
-                    await (0, promises_1.mkdir)(tableSharedPath, { recursive: true });
-                    await (0, promises_1.chmod)(tableSharedPath, 0o777);
-                    try {
-                        await sql.csvDump({
-                            sharedPath: tableSharedPath,
+                    else {
+                        const outPath = (0, path_1.join)(outputPath, `${tableName}${suffix.table}`);
+                        await sql.dump({
+                            output: outPath,
                             items: [tableName],
                             database: this.config.database,
+                            onSpawn: (p) => (controller.stop = () => p.kill()),
+                            ...(concurrency !== 1 && {
+                                onProgress(progress) {
+                                    data.onProgress({
+                                        relative: {
+                                            description: "Exporting",
+                                            payload: tableName,
+                                            current: progress.totalBytes,
+                                            format: "size",
+                                        },
+                                        absolute: {
+                                            total: tableNames.length,
+                                            current: index,
+                                            percent: (0, math_1.progressPercent)(tableNames.length, index),
+                                        },
+                                    });
+                                },
+                            }),
                         });
-                        const files = await (0, promises_1.readdir)(tableSharedPath);
-                        const schemaFile = `${tableName}.sql`;
-                        const dataFile = `${tableName}.txt`;
-                        const successCsvDump = files.length === 2 &&
-                            files.every((file) => file === schemaFile || file === dataFile);
-                        if (!successCsvDump)
-                            throw new AppError_1.AppError(`Invalid csv dump files: ${files.join(", ")}`);
-                        await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, schemaFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableSchema}`));
-                        await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, dataFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableData}`));
-                    }
-                    finally {
-                        await (0, promises_1.rm)(tableSharedPath, { recursive: true });
                     }
-                }
-                else {
-                    const outPath = (0, path_1.join)(outputPath, `${tableName}${suffix.table}`);
-                    await sql.dump({
-                        output: outPath,
-                        items: [tableName],
-                        database: this.config.database,
-                        onProgress(progress) {
-                            data.onProgress({
-                                relative: {
-                                    description: "Exporting",
-                                    payload: tableName,
-                                    current: progress.totalBytes,
-                                    format: "size",
-                                },
-                                absolute: {
-                                    total: tableNames.length,
-                                    current,
-                                    percent: (0, math_1.progressPercent)(tableNames.length, current),
-                                },
-                            });
-                        },
-                    });
-                }
-                current++;
-            }
+                },
+            });
         }
         else {
             await data.onProgress({
@@ -136,7 +145,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
         }
     }
     async onRestore(data) {
-        const sql = (0, mysql_1.createMysqlCli)({
+        const sql = await (0, mysql_1.createMysqlCli)({
             ...this.config,
             verbose: data.options.verbose,
         });
@@ -181,47 +190,68 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
         await sql.createDatabase(database);
         if (data.options.verbose)
             (0, cli_1.logExec)("readdir", [restorePath]);
-        let current = 0;
-        for (const file of files.filter((f) => !f.endsWith(suffix.tableData))) {
-            const path = (0, path_1.join)(restorePath, file);
-            data.onProgress({
+        const concurrency = this.config.concurrency ?? 1;
+        let processed = 0;
+        await (0, async_1.runParallel)({
+            items: files.filter((f) => !f.endsWith(suffix.tableData)),
+            concurrency,
+            onFinished: () => {
+                processed++;
+            },
+            onChange: async ({ buffer }) => await data.onProgress({
                 relative: {
-                    description: "Importing",
-                    payload: file,
+                    description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
+                    payload: [...buffer.keys()].join(", "),
                 },
                 absolute: {
                     total: files.length,
-                    current: current,
-                    percent: (0, math_1.progressPercent)(files.length, current),
+                    current: processed,
+                    percent: (0, math_1.progressPercent)(files.length, processed),
                 },
-            });
-            await sql.importFile(path, database.name);
-            current++;
-        }
-        for (const file of dataFiles) {
-            const filePath = (0, path_1.join)(restorePath, file);
-            const tableName = file.slice(0, suffix.tableData.length * -1);
-            data.onProgress({
+            }),
+            onItem: async ({ item: file, controller }) => {
+                await sql.importFile({
+                    path: (0, path_1.join)(restorePath, file),
+                    database: database.name,
+                    onSpawn: (p) => (controller.stop = () => p.kill()),
+                });
+            },
+        });
+        await (0, async_1.runParallel)({
+            items: dataFiles,
+            concurrency,
+            onFinished: () => {
+                processed++;
+            },
+            onChange: async ({ buffer }) => await data.onProgress({
                 relative: {
-                    description: "Importing",
-                    payload: file,
+                    description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
+                    payload: [...buffer.keys()].join(", "),
                 },
                 absolute: {
                     total: files.length,
-                    current: current,
-                    percent: (0, math_1.progressPercent)(files.length, current),
+                    current: processed,
+                    percent: (0, math_1.progressPercent)(files.length, processed),
                 },
-            });
-            const sharedFilePath = (0, path_1.join)(sharedDir, `tmp-dtt-restore-${data.snapshot.id.slice(0, 8)}-${tableName}.data.csv`);
-            try {
-                await (0, fs_1.safeRename)(filePath, sharedFilePath);
-                await sql.importCsvFile(sharedFilePath, database.name, tableName);
-            }
-            finally {
-                await (0, promises_1.rm)(sharedFilePath);
-            }
-            current++;
-        }
+            }),
+            onItem: async ({ item: file, controller }) => {
+                const filePath = (0, path_1.join)(restorePath, file);
+                const tableName = file.slice(0, suffix.tableData.length * -1);
+                const sharedFilePath = (0, path_1.join)(sharedDir, `tmp-dtt-restore-${data.snapshot.id.slice(0, 8)}-${tableName}.data.csv`);
+                try {
+                    await (0, fs_1.safeRename)(filePath, sharedFilePath);
+                    await sql.importCsvFile({
+                        path: sharedFilePath,
+                        database: database.name,
+                        table: tableName,
+                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                    });
+                }
+                finally {
+                    await (0, promises_1.rm)(sharedFilePath);
+                }
+            },
+        });
     }
 }
 exports.MysqlDumpTask = MysqlDumpTask;

package/config.schema.json

@@ -895,6 +895,10 @@
             "sql"
           ]
         },
+        "concurrency": {
+          "type": "integer",
+          "minimum": 1
+        },
         "csvSharedPath": {
           "type": "string"
         },

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.22.2",
+  "version": "0.23.1",
   "dependencies": {
+    "@supercharge/promise-pool": "^3.1.0",
     "ajv": "^8.12.0",
     "async": "^3.2.4",
     "chalk": "^4.1.2",
@@ -11,6 +12,7 @@
     "fast-folder-size": "^2.2.0",
     "fast-glob": "^3.3.1",
     "micromatch": "^4.0.5",
+    "mysql2": "^3.6.1",
     "pretty-bytes": "^5.6.0",
     "sqlite": "^5.0.1",
     "sqlite3": "^5.1.6"

package/utils/async.d.ts

@@ -0,0 +1,20 @@
+type ControllerItem = {
+    stop?: () => void;
+};
+type ItemBuffer<T> = Map<T, ControllerItem>;
+export declare function runParallel<T>(options: {
+    items: T[];
+    concurrency: number;
+    onChange: (data: {
+        buffer: ItemBuffer<T>;
+        processed: number;
+        proccesing: number;
+    }) => Promise<void> | void;
+    onItem: (data: {
+        item: T;
+        index: number;
+        controller: ControllerItem;
+    }) => Promise<void> | void;
+    onFinished?: () => Promise<void> | void;
+}): Promise<void>;
+export {};

package/utils/async.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runParallel = void 0;
+const promise_pool_1 = require("@supercharge/promise-pool");
+async function runParallel(options) {
+    const buffer = new Map();
+    let processed = 0;
+    let error;
+    await promise_pool_1.PromisePool.for(options.items)
+        .withConcurrency(options.concurrency)
+        .process(async (item, index, pool) => {
+        const controller = {};
+        buffer.set(item, controller);
+        try {
+            await options.onChange({
+                processed,
+                proccesing: buffer.size,
+                buffer,
+            });
+            await options.onItem({
+                item,
+                index,
+                controller,
+            });
+        }
+        catch (_error) {
+            error = _error;
+            buffer.delete(item);
+            pool.stop();
+            for (const [, $controller] of buffer.entries())
+                try {
+                    $controller.stop?.();
+                }
+                catch (_) { }
+        }
+        finally {
+            buffer.delete(item);
+            processed++;
+            await options.onFinished?.();
+            await options.onChange({
+                processed,
+                proccesing: buffer.size,
+                buffer,
+            });
+        }
+    });
+    if (error)
+        throw error;
+}
+exports.runParallel = runParallel;

package/utils/mysql.d.ts

@@ -1,3 +1,4 @@
+import { ChildProcess } from "child_process";
 export type MysqlCliOptions = {
     password: string | {
         path: string;
@@ -6,24 +7,33 @@ export type MysqlCliOptions = {
     port?: number;
     username: string;
     verbose?: boolean;
+    database?: string;
 };
-export declare function createMysqlCli(options: MysqlCliOptions): {
+export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
     options: MysqlCliOptions;
     initSharedDir: (sharedDir?: string) => Promise<string>;
     args: () => Promise<string[]>;
-    run: (query: string, database?: string, extra?: string[]) => Promise<import("./process").ExecResultType>;
-    fetchAll: (query: string, database?: string) => Promise<string[][]>;
+    run: (query: string, database?: string, extra?: string[], onSpawn?: ((p: ChildProcess) => void) | undefined) => Promise<import("./process").ExecResultType>;
+    execute: (query: string, params?: any[]) => Promise<void>;
+    insert: (tableName: string, item: Record<string, any>) => Promise<void>;
+    changeDatabase: (name: string) => Promise<void>;
+    fetchAll: <T>(query: string, params?: any[]) => Promise<T[]>;
     dump: (input: {
         output: string;
         database: string;
         items?: string[] | undefined;
         onlyStoredPrograms?: boolean | undefined;
+        onSpawn?: ((p: ChildProcess) => void) | undefined;
         onProgress?: ((data: {
             totalBytes: number;
         }) => void) | undefined;
     }) => Promise<[void, import("./process").ExecResultType]>;
     fetchTableNames: (database: string, include?: string[], exclude?: string[]) => Promise<string[]>;
-    importFile: (path: string, database: string) => Promise<import("./process").ExecResultType>;
+    importFile: (input: {
+        path: string;
+        database: string;
+        onSpawn?: ((p: ChildProcess) => void) | undefined;
+    }) => Promise<import("./process").ExecResultType>;
     isDatabaseEmpty: (database: string) => Promise<boolean>;
     createDatabase: (database: {
         name: string;
@@ -32,8 +42,14 @@ export declare function createMysqlCli(options: MysqlCliOptions): {
     csvDump: (input: {
         database: string;
         sharedPath: string;
-        items?: string[];
+        items?: string[] | undefined;
+        onSpawn?: ((p: ChildProcess) => void) | undefined;
     }) => Promise<void>;
-    importCsvFile: (path: string, database: string, table: string) => Promise<import("./process").ExecResultType>;
+    importCsvFile: (input: {
+        path: string;
+        database: string;
+        table: string;
+        onSpawn?: ((p: ChildProcess) => void) | undefined;
+    }) => Promise<import("./process").ExecResultType>;
     fetchVariable: (name: string) => Promise<string | undefined>;
-};
+}>;

package/utils/mysql.js

@@ -2,19 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMysqlCli = void 0;
 const AppError_1 = require("../Error/AppError");
+const cli_1 = require("./cli");
 const fs_1 = require("./fs");
 const process_1 = require("./process");
 const string_1 = require("./string");
 const crypto_1 = require("crypto");
 const fs_2 = require("fs");
 const promises_1 = require("fs/promises");
+const promise_1 = require("mysql2/promise");
 const os_1 = require("os");
 const path_1 = require("path");
-function createMysqlCli(options) {
-    let defaultsFilePath;
-    async function getDefaultsFilePath() {
-        if (defaultsFilePath)
-            return defaultsFilePath;
+function flatQuery(query, params) {
+    query = query.replace(/\s{1,}/g, " ").trim();
+    let paramIndex = 0;
+    return params
+        ? query.replace(/\?/g, () => {
+            const param = params[paramIndex++];
+            return param ? JSON.stringify(param) : "?";
+        })
+        : query;
+}
+async function createMysqlCli(options) {
+    let sqlConfigPath;
+    const password = (await (0, fs_1.fetchData)(options.password, (p) => p.path)) ?? "";
+    const sql = await (0, promise_1.createConnection)({
+        host: options.hostname,
+        user: options.username,
+        password,
+        port: options.port,
+        database: options.database,
+    });
+    async function createSqlConfig() {
+        if (sqlConfigPath)
+            return sqlConfigPath;
         const dir = await (0, fs_1.mkTmpDir)("mysql-cli");
         const password = await (0, fs_1.fetchData)(options.password, (p) => p.path);
         const data = [
@@ -24,29 +44,31 @@ function createMysqlCli(options) {
             `user = "${options.username}"`,
             `password = "${password}"`,
         ];
-        await (0, promises_1.writeFile)((defaultsFilePath = (0, path_1.join)(dir, "mysql.conf")), data.join("\n"));
-        return defaultsFilePath;
+        await (0, promises_1.writeFile)((sqlConfigPath = (0, path_1.join)(dir, "mysql.conf")), data.join("\n"));
+        return sqlConfigPath;
     }
     async function args() {
-        return [`--defaults-file=${await getDefaultsFilePath()}`];
+        return [`--defaults-file=${await createSqlConfig()}`];
     }
-    async function run(query, database, extra = []) {
+    async function run(query, database, extra = [], onSpawn) {
         return await (0, process_1.exec)("mysql", [
             ...(await args()),
             ...(database ? [database] : []),
             ...(extra || []),
             "-e",
-            query.replace(/\s{1,}/g, " "),
+            flatQuery(query),
             "-N",
             "--silent",
         ], undefined, {
+            onSpawn,
             log: options.verbose,
             stderr: { toExitCode: true },
             stdout: { save: true },
         });
     }
-    async function fetchAll(query, database) {
-        return (0, string_1.splitLines)((await run(query, database)).stdout).map((line) => line.split("\t"));
+    async function fetchAll(query, params) {
+        const [rows] = await sql.query(query, params);
+        return rows;
     }
     async function fetchTableNames(database, include, exclude) {
         return (await fetchAll(`
@@ -55,11 +77,11 @@ function createMysqlCli(options) {
       FROM
         information_schema.tables
       WHERE
-        table_schema = '${database}'
+        table_schema = ?
       ORDER BY
         table_name
-  `))
-            .map((r) => r[0])
+  `, [database]))
+            .map((r) => r.table_name)
             .filter((0, string_1.createMatchFilter)(include, exclude));
     }
     async function dump(input) {
@@ -88,6 +110,7 @@ function createMysqlCli(options) {
                 ...(input.items || []),
             ], null, {
                 stderr: { toExitCode: true },
+                onSpawn: input.onSpawn,
                 pipe: {
                     stream,
                     onWriteProgress: input.onProgress,
@@ -106,11 +129,14 @@ function createMysqlCli(options) {
             input.database,
             "--lock-tables=false",
             "--skip-add-drop-table=false",
+            "--fields-terminated-by=0x09",
+            "--lines-terminated-by=0x0a",
             "-T",
             input.sharedPath,
             ...(input.items || []),
         ], null, {
             stderr: { toExitCode: true },
+            onSpawn: input.onSpawn,
             log: {
                 exec: options.verbose,
                 stderr: options.verbose,
@@ -118,7 +144,7 @@ function createMysqlCli(options) {
             },
         });
     }
-    async function importFile(path, database) {
+    async function importFile(input) {
         return await (0, process_1.exec)("mysql", [
             ...(await args()),
             `--init-command=SET ${[
@@ -126,10 +152,11 @@ function createMysqlCli(options) {
                 "unique_checks=0",
                 "foreign_key_checks=0",
             ].join(",")};`,
-            database,
+            input.database,
         ], null, {
+            onSpawn: input.onSpawn,
             pipe: {
-                stream: (0, fs_2.createReadStream)(path),
+                stream: (0, fs_2.createReadStream)(input.path),
                 onReadProgress: (data) => {
                     if (options.verbose)
                         (0, process_1.logExecStdout)({
@@ -144,35 +171,36 @@ function createMysqlCli(options) {
             log: options.verbose,
         });
     }
-    async function importCsvFile(path, database, table) {
+    async function importCsvFile(input) {
         return run(`
-      LOAD DATA LOCAL INFILE '${path.replaceAll("\\", "/")}'
-      INTO TABLE ${table}
-      FIELDS TERMINATED BY ','
-      ENCLOSED BY '"'
-      LINES TERMINATED BY '\\n'`, database, ["--local-infile"]);
+      LOAD DATA LOCAL INFILE ${JSON.stringify(input.path.replaceAll("\\", "/"))}
+      INTO TABLE ${input.table}
+      FIELDS TERMINATED BY '\\t'
+      LINES TERMINATED BY '\\n'`, input.database, ["--local-infile"], input.onSpawn);
     }
     async function isDatabaseEmpty(database) {
-        const [total] = await fetchAll(`
+        const [row] = await fetchAll(`
       SELECT
         COUNT(*) AS total 
       FROM
         information_schema.tables
       WHERE
-        table_schema = '${database}'
-    `);
-        return Number(total) ? false : true;
+        table_schema = ?
+    `, [database]);
+        return Number(row.total) ? false : true;
     }
     async function createDatabase(database) {
-        await run(`
+        await sql.execute(`
       CREATE DATABASE IF NOT EXISTS \`${database.name}\`
       CHARACTER SET ${database.charset ?? "utf8"}
       COLLATE ${database.charset ?? "utf8_general_ci"}
     `);
     }
     async function fetchVariable(name) {
-        const stdout = (0, string_1.undefIfEmpty)((await run(`SHOW VARIABLES LIKE "${name}"`)).stdout.trim());
-        return stdout ? (0, string_1.undefIfEmpty)(stdout.slice(name.length).trim()) : undefined;
+        const rows = await fetchAll(`SHOW VARIABLES LIKE ?`, [
+            name,
+        ]);
+        return (0, string_1.undefIfEmpty)(rows?.[0].Value);
     }
     async function initSharedDir(sharedDir) {
         const secure_file_priv = await fetchVariable("secure_file_priv");
@@ -192,7 +220,7 @@ function createMysqlCli(options) {
         try {
             await (0, fs_1.mkdirIfNotExists)(dir);
             await (0, promises_1.chmod)(dir, 0o777);
-            await run(`SELECT 1 INTO OUTFILE ${outFileVar}`);
+            await sql.execute(`SELECT 1 INTO OUTFILE ${outFileVar}`);
             const exists = await (0, fs_1.existsFile)(outFile);
             if (!exists)
                 throw new AppError_1.AppError(`MySQL shared dir is not reached: ${dir}`);
@@ -204,11 +232,38 @@ function createMysqlCli(options) {
             catch (e) { }
         }
     }
+    async function execute(query, params = []) {
+        if (options.verbose) {
+            (0, cli_1.logExec)(`mysql`, [
+                ...(await args()),
+                "-e",
+                `"${flatQuery(query)}"`,
+                ...(sql.config.database ? [sql.config.database] : []),
+            ]);
+        }
+        await sql.execute(query, params);
+    }
+    async function insert(tableName, item) {
+        const columnsExpr = Object.keys(item)
+            .map((v) => v)
+            .join(", ");
+        const paramsExpr = Array.from({ length: Object.keys(item).length })
+            .fill("?")
+            .join(", ");
+        const params = Object.values(item);
+        await execute(`INSERT INTO ${tableName} (${columnsExpr}) VALUES (${paramsExpr})`, params);
+    }
+    async function changeDatabase(name) {
+        await sql.changeUser({ database: name });
+    }
     return {
         options,
         initSharedDir,
         args,
         run,
+        execute,
+        insert,
+        changeDatabase,
         fetchAll,
         dump,
         fetchTableNames,