@cleverbrush/knex-clickhouse 1.1.6 → 1.1.8

package/dist/index.d.ts

@@ -1,9 +1,21 @@
 import Knex from 'knex';
-import ClickhouseDriver from '@clickhouse/client';
+import ClickhouseDriver, { type ClickHouseSettings } from '@clickhouse/client';
+import { retry } from '@cleverbrush/async';
+type AdditionalClientOptions = {
+    /**
+     * Options for retrying the query,
+     * by default it will retry 10 times with a delay factor of 2 and a minimum delay of
+     * 100ms and delay randomization of 10%.
+     * and will retry only if the error code is 'ECONNRESET',
+     * you can override this behavior by passing your own options.
+     * If this option is set to `null` then the query will not be retried.
+     */
+    retry?: Parameters<typeof retry>[1];
+};
 export declare class ClickhouseKnexClient extends Knex.Client {
     #private;
     _driver(): typeof ClickhouseDriver;
-    constructor(config?: {});
+    constructor(config?: Knex.Knex.Config<any> & AdditionalClientOptions);
     _escapeBinding(value: any): any;
     /**
      *
@@ -22,3 +34,9 @@ export declare class ClickhouseKnexClient extends Knex.Client {
     acquireRawConnection(): Promise<any>;
     destroyRawConnection(connection: any): Promise<void>;
 }
+/**
+ *
+ * @returns {import('knex').Knex<any, unknown[]>}
+ */
+export declare const getClickhouseConnection: (config?: Knex.Knex.Config<any> & AdditionalClientOptions, clickHouseSettings?: ClickHouseSettings) => Knex.Knex<any, unknown[]>;
+export {};

package/dist/index.js

@@ -1,5 +1,7 @@
 import Knex from 'knex';
 import ClickhouseDriver from '@clickhouse/client';
+import { retry } from '@cleverbrush/async';
+import { deepExtend } from '@cleverbrush/deep';
 import { makeEscape } from './makeEscape.js';
 const parseDate = (value) => new Date(Date.parse(value));
 // this function is taken from knex npm package
@@ -28,8 +30,19 @@ export class ClickhouseKnexClient extends Knex.Client {
     _driver() {
         return ClickhouseDriver;
     }
+    #retryOptions;
     constructor(config = {}) {
+        const { retry: retryOptions } = config;
         super(config);
+        this.#retryOptions = retryOptions
+            ? deepExtend({
+                maxRetries: 10,
+                delayFactor: 2,
+                minDelay: 100,
+                delayRandomizationPercent: 0.1,
+                shouldRetry: (error) => error.code === 'ECONNRESET'
+            }, retryOptions)
+            : null;
     }
     #typeParsers = {
         Date: parseDate,
@@ -125,14 +138,18 @@ export class ClickhouseKnexClient extends Knex.Client {
             case 'first':
             case 'pluck':
                 {
-                    const p = await connection.query(queryParams);
+                    const p = (await (this.#retryOptions
+                        ? retry(() => connection.query(queryParams), this.#retryOptions)
+                        : connection.query(queryParams)));
                     response = await p.json();
                     const { data, meta, ...rest } = response;
                     obj.response = [data, meta, { ...rest }];
                 }
                 break;
             default:
-                response = await connection.exec(queryParams);
+                response = await (this.#retryOptions
+                    ? retry(() => connection.exec(queryParams), this.#retryOptions)
+                    : connection.exec(queryParams));
         }
         return obj;
     }
@@ -199,7 +216,9 @@ export class ClickhouseKnexClient extends Knex.Client {
                 password: this.config.connection.password,
                 // @ts-ignore
                 database: this.config.connection.database,
-                compression: { request: true, response: true }
+                compression: { request: true, response: true },
+                // @ts-ignore
+                clickhouse_settings: this.config.clickHouseSettings
             });
             // @ts-ignore
             connection.connected = true;
@@ -216,3 +235,48 @@ Object.assign(ClickhouseKnexClient.prototype, {
     driverName: 'clikhouse',
     canCancelQuery: true
 });
+const registerKnexClickhouseExtensions = (knex) => {
+    Knex.QueryBuilder.extend('insertToClickhouse', function (rows) {
+        const getTuple = (r, p = ['(', ')']) => p[0] +
+            r
+                .map((c) => {
+                if (c === null) {
+                    return 'NULL';
+                }
+                if (typeof c === 'string') {
+                    return knex.raw('?', [c]).toQuery();
+                }
+                if (Array.isArray(c)) {
+                    return getTuple(c, ['[', ']']);
+                }
+                if (typeof c === 'object') {
+                    const keys = Object.keys(c);
+                    return `[${keys
+                        .map((k) => `(${knex.raw('?', [k]).toQuery()}, ${knex
+                        .raw('?', [c[k]])
+                        .toQuery()})`)
+                        .join(', ')}]`;
+                }
+                return c;
+            })
+                .join(', ') +
+            p[1];
+        const values = rows.map((r) => getTuple(r));
+        // @ts-ignore
+        return knex.raw(`INSERT INTO ${this._single.table} VALUES ${values}`);
+    });
+};
+/**
+ *
+ * @returns {import('knex').Knex<any, unknown[]>}
+ */
+export const getClickhouseConnection = (config = {}, clickHouseSettings) => {
+    const connection = Knex({
+        ...config,
+        client: ClickhouseKnexClient,
+        // @ts-ignore
+        clickHouseSettings
+    });
+    registerKnexClickhouseExtensions(connection);
+    return connection;
+};

package/package.json

@@ -5,6 +5,8 @@
         "email": "andrew_zol@cleverbrush.com"
     },
     "dependencies": {
+        "@cleverbrush/async": "^1.1.8",
+        "@cleverbrush/deep": "^1.1.8",
         "@clickhouse/client": "^1.0.1"
     },
     "peerDependencies": {
@@ -35,5 +37,5 @@
     },
     "type": "module",
     "types": "./dist/index.d.ts",
-    "version": "1.1.6"
+    "version": "1.1.8"
 }