dobo-clickhouse 2.2.1

package/.jsdoc.conf.json

@@ -0,0 +1,45 @@
+{
+  "plugins": ["plugins/markdown", "jsdoc-plugin-intersection"],
+  "opts": {
+    "encoding": "utf8",
+    "recurse": true,
+    "verbose": true,
+    "destination": "./docs",
+    "template": "node_modules/clean-jsdoc-theme",
+    "readme": "./docs/static/home.md",
+    "theme_opts": {
+      "default_theme": "light",
+      "display-module-header": true,
+      "title": "DoboRedis API",
+      "homepageTitle": "DoboRedis API",
+      "sections": ["Classes", "Events", "Modules", "Global"],
+      "menu": [{
+        "title": "NPM",
+        "link": "https://www.npmjs.com/package/dobo-couchdb"
+      }, {
+        "title": "Github",
+        "link": "https://github.com/ardhi/dobo-couchdb"
+      }, {
+        "title": "Dobo",
+        "link": "https://dobo.bajo.app/"
+      }, {
+        "title": "Bajo",
+        "link": "https://bajo.app/"
+      }]
+    }
+  },
+  "source": {
+    "include": ["."],
+    "includePattern": ".+\\.js(doc|x)?$",
+    "exclude": ["node_modules", "docs", "test"]
+  },
+  "markdown": {
+    "hardwrap": false,
+    "idInHeadings": true
+  },
+  "sourceType": "module",
+  "templates": {
+    "cleverLinks": false,
+    "monospaceLinks": false
+  }
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2025 Ardhi Lukianto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# dobo-clickhouse
+
+![GitHub package.json version](https://img.shields.io/github/package-json/v/ardhi/dobo-clickhouse) ![NPM Version](https://img.shields.io/npm/v/dobo-clickhouse)
+
+> <br />**Attention**: I do NOT accept any pull request at the moment, thanks! ([Why?](wiki/CONTRIBUTING.md))<br /><br />
+
+Clickhouse driver for [Dobo](https://github.com/ardhi/dobo)
+
+## Installation
+
+First, go to your ```{appDir}``` and run the following command in your terminal:
+
+```bash
+$ npm install dobo dobo-clickhouse
+```
+
+And enable the plugin by adding ```dobo```, ```dobo-knex``` and ```dobo-clickhouse``` to the plugin list in either the ```$dataDir/config/.plugins``` file or the ```bajo.plugins``` array within your ```package.json``` file
+
+## Documentations
+
+- [Config Object](wiki/CONFIG.md)
+- [API](https://ardhi.github.io/dobo-clickhouse)
+- [Contributing](wiki/CONTRIBUTING.md)
+
+## Hire Me
+
+If you have a Bajo Framework-based project and need a professional service or assistance, please <a href="https://github.com/ardhi#professional-service">click here</a>. I'd be happy to work on it at a competitive price and with fast turnaround!
+
+## Support Me
+
+Please support me using the channels below. Your donation will motivate me to work faster and more diligently on future development.
+
+<a href="https://github.com/sponsors/ardhi">
+  <img src="https://img.shields.io/badge/Github-slategrey?style=flat&logo=github" height="50">
+</a>
+<a href="https://www.patreon.com/bajoframework">
+  <img src="https://img.shields.io/badge/Patreon-f2c3b2?style=flat&logo=patreon" height="50">
+</a>
+<a href="https://www.paypal.com/ncp/payment/EWLERL7SCUU64">
+  <img src="https://img.shields.io/badge/Paypal-blue?style=flat&logo=paypal" height="50">
+</a>
+
+<p>
+<div><img alt="bc1qwtv78cwp9ef8hnqaw84fxg5856l0pggqe32g6f" src="docs/static/bitcoin.jpeg" width="150" height="150" /><br>Bitcoin</div>
+</p>
+
+## License
+
+[MIT](LICENSE)

package/extend/dobo/driver/clickhouse.js

@@ -0,0 +1,59 @@
+import clientFactory from '../../../lib/dialect/client.js'
+
+async function clickhouseDriverFactory () {
+  const { DoboKnexDriver } = this.app.baseClass
+
+  class DoboClickhouseDriver extends DoboKnexDriver {
+    constructor (plugin, name, options) {
+      super(plugin, name, options)
+      this.idField = {
+        name: 'id',
+        type: 'string',
+        required: true,
+        autoInc: true,
+        index: 'primary'
+      }
+      this.idGenerator = 'uuidv7'
+      this.defaultEngine = 'MergeTree'
+      this.support.returning = false
+      this.support.uniqueIndex = false
+      this.support.nullableField = false
+    }
+
+    async sanitizeConnection (item) {
+      await super.sanitizeConnection(item)
+      item.port = item.port ?? 8123
+      item.user = item.user ?? 'default'
+      item.host = item.host ?? '127.0.0.1'
+      item.database = item.database ?? 'default'
+    }
+
+    async connect (connection, noRebuild) {
+      const { importPkg } = this.app.bajo
+      const knex = await importPkg('doboKnex:knex')
+      const client = await clientFactory.call(this.plugin)
+      const { user, password, host, port, database } = connection.options
+      connection.client = knex({
+        client,
+        connection: () => {
+          return `clickhouse://${user}:${password}@${host}:${port}/${database}`
+        },
+        ...this.options
+      })
+    }
+
+    async updateRecord (model, id, body = {}, options = {}) {
+      const oldData = options._data
+      const client = model.connection.client
+      const result = await client(model.collName).where('id', id).update(body, this._getReturningFields(model, options))
+      if (options.noResult) return
+      if (this.support.returning) return { data: result[0], oldData }
+      const resp = await this.getRecord(model, id)
+      return { data: resp.data, oldData }
+    }
+  }
+
+  return DoboClickhouseDriver
+}
+
+export default clickhouseDriverFactory

package/index.js

@@ -0,0 +1,30 @@
+/**
+ * Plugin factory
+ *
+ * @param {string} pkgName - NPM package name
+ * @returns {class}
+ */
+async function factory (pkgName) {
+  const me = this
+
+  /**
+   * DoboClickhouse class
+   *
+   * @class
+   */
+  class DoboClickhouse extends this.app.baseClass.Base {
+    constructor () {
+      super(pkgName, me.app)
+      this.config = {
+        connections: []
+      }
+    }
+
+    exit = () => {
+    }
+  }
+
+  return DoboClickhouse
+}
+
+export default factory

package/lib/dialect/client.js

@@ -0,0 +1,239 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/client.js
+import ClickHouse from 'clickhouse'
+import _qc from './query/compiler.js'
+import _sc from './schema/compiler.js'
+import _tc from './schema/tablecompiler.js'
+import _cc from './schema/columncompiler.js'
+import TransactionClickHouse from './transaction.js'
+import sqlString from 'sqlstring'
+
+function ltrimSlashes (v) {
+  return v.replace(/^\//g, '')
+}
+
+async function clientFactory () {
+  const { importModule } = this.app.bajo
+  const { isString, isFunction, assign, map } = this.app.lib._
+  const makeEscape = (await importModule('doboKnex:node_modules/knex/lib/util/string.js')).makeEscape
+  const TableBuilder = await importModule('doboKnex:node_modules/knex/lib/schema/tablebuilder.js')
+  const Client = await importModule('doboKnex:node_modules/knex/lib/client.js')
+  const QueryCompiler = await _qc.call(this)
+  const SchemaCompilerClickHouse = await _sc.call(this)
+  const TableCompilerClickHouse = await _tc.call(this)
+  const ColumnCompilerClickHouse = await _cc.call(this)
+
+  class ClickhouseClient extends Client {
+    dialect = 'clickhouse'
+    driverName = 'clickhouse'
+    _escapeBinding = makeEscape()
+    canCancelQuery = true
+    _migrationLockTableName = '`knex_migrations_lock`'
+
+    constructor (config = {}) {
+      super(config)
+      this.initializeDriver()
+      this.initializePool()
+      if (config.migrations && config.migrations.tableName) {
+        const migrationCfg = config.migrations
+        if (migrationCfg.schemaName) {
+          this._migrationLockTableName = '`' + migrationCfg.schemaName + '`.`' + migrationCfg.tableName + '_lock`'
+        } else {
+          this._migrationLockTableName = '`' + migrationCfg.tableName + '_lock`'
+        }
+      }
+    }
+
+    _driver () {
+      return ClickHouse
+    }
+
+    tableBuilder (type, tableName, tableNameLike, fn) {
+      const builder = new TableBuilder(this, type, tableName, tableNameLike, fn)
+      builder.engine = function (val) {
+        this._single.engine = val
+      }
+      return builder
+    }
+
+    queryCompiler (...args) {
+      return new QueryCompiler(this, ...args)
+    }
+
+    schemaCompiler (builder) {
+      return new SchemaCompilerClickHouse(this, builder)
+    }
+
+    tableCompiler (tableBuilder) {
+      return new TableCompilerClickHouse(this, tableBuilder)
+    }
+
+    columnCompiler () {
+      return new ColumnCompilerClickHouse(this, ...arguments)
+    }
+
+    async transaction () {
+      return new TransactionClickHouse(this, ...arguments)
+    }
+
+    wrapIdentifierImpl (value) {
+      return value !== '*' ? `\`${value.replace(/`/g, '``')}\`` : '*'
+    }
+
+    // Get a raw connection, called by the `pool` whenever a new
+    // connection needs to be added to the pool.
+    async acquireRawConnection () {
+      const config = await this.getConfiguration()
+      return new (this.driver.ClickHouse)(config)
+    }
+
+    async getConfiguration () {
+      let config = this.config.connection
+      if (isFunction(config)) {
+        config = await config()
+      }
+      if (isString(config)) {
+        const url = new URL(config)
+        config = {
+          url: url.hostname,
+          port: url.port ? url.port : 8123,
+          user: url.username,
+          password: url.password,
+          database: ltrimSlashes(url.pathname),
+          debug: false,
+          basicAuth: null,
+          isUseGzip: false,
+          usePost: true,
+          config: {
+            session_timeout: 60,
+            output_format_json_quote_64bit_integers: 0,
+            enable_http_compression: 0
+          }
+        }
+      }
+
+      return config
+    }
+
+    // Used to explicitly close a connection, called internally by the pool
+    // when a connection times out or the pool is shutdown.
+    destroyRawConnection (connection) {
+      connection.destroy()
+    }
+
+    // eslint-disable-next-line no-unused-vars
+    validateConnection (connection) {
+      return true
+    }
+
+    // Grab a connection, run the query via the MySQL streaming interface,
+    // and pass that through to the stream we've sent back to the client.
+    _stream (connection, obj, stream, options) {
+      options = options || {}
+      const queryOptions = assign({ sql: obj.sql }, obj.options)
+      return new Promise((resolve, reject) => {
+        stream.on('error', reject)
+        stream.on('end', resolve)
+        const queryStream = connection
+          .query(queryOptions, obj.bindings)
+          .stream(options)
+
+        queryStream.on('error', (err) => {
+          reject(err)
+          stream.emit('error', err)
+        })
+
+        queryStream.pipe(stream)
+      })
+    }
+
+    /**
+     * Runs the query on the specified connection, providing the bindingsand any other necessary prep work.
+     */
+    async _query (connection, obj) {
+      if (!obj || typeof obj === 'string') obj = { sql: obj }
+      // dirty hack for knex-migrator
+      if (['insert', 'update'].includes(obj.method) && obj.sql.indexOf(this._migrationLockTableName) > -1) {
+        obj.response = [[], []]
+        return obj
+      }
+      return new Promise((resolve, reject) => {
+        if (!obj.sql) {
+          resolve()
+          return
+        }
+
+        const queryOptions = assign({ sql: obj.sql }, obj.options)
+        const query = this._applyBindings(queryOptions.sql, obj.bindings)
+
+        connection.query(query, (err, rows, fields) => {
+          if (err) return reject(err)
+          obj.response = [rows, fields]
+          resolve(obj)
+        })
+      })
+    }
+
+    _applyBindings (sql, bindings) {
+      for (let i = 0; i < bindings.length; i++) {
+        if (bindings[i] instanceof Date) {
+          bindings[i] = bindings[i].toISOString()
+            .replace(/T/, ' ')
+            .replace(/\..+/, '')
+        }
+      }
+      return sqlString.format(sql, bindings)
+    }
+
+    // Process the response as returned from the query.
+    processResponse (obj, runner) {
+      if (obj == null) return
+      const { response } = obj
+      const { method } = obj
+      const rows = response[0]
+      const fields = response[1]
+      if (obj.output) return obj.output.call(runner, rows, fields)
+      switch (method) {
+        case 'select':
+        case 'pluck':
+        case 'first': {
+          if (method === 'pluck') return map(rows, obj.pluck)
+          return method === 'first' ? rows[0] : rows
+        }
+        case 'insert':
+          return [rows.insertId]
+        case 'del':
+        case 'update':
+        case 'counter':
+          return rows.affectedRows
+        default:
+          return response
+      }
+    }
+
+    cancelQuery (connectionToKill) {
+      const acquiringConn = this.acquireConnection()
+
+      // Error out if we can't acquire connection in time.
+      // Purposely not putting timeout on `KILL QUERY` execution because erroring
+      // early there would release the `connectionToKill` back to the pool with
+      // a `KILL QUERY` command yet to finish.
+      return acquiringConn
+        .timeout(100)
+        .then((conn) => this.query(conn, {
+          method: 'raw',
+          sql: 'KILL QUERY ?',
+          bindings: [connectionToKill.threadId],
+          options: {}
+        }))
+        .finally(() => {
+          // NOT returning this promise because we want to release the connection
+          // in a non-blocking fashion
+          acquiringConn.then((conn) => this.releaseConnection(conn))
+        })
+    }
+  }
+
+  return ClickhouseClient
+}
+
+export default clientFactory

package/lib/dialect/query/compiler.js

@@ -0,0 +1,76 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/query/compiler.js
+
+async function factory () {
+  const { importModule } = this.app.bajo
+  const { identity } = this.app.lib._
+  const QueryCompiler = await importModule('doboKnex:node_modules/knex/lib/query/querycompiler.js')
+
+  class QueryCompilerClickhouse extends QueryCompiler {
+    _emptyInsertValue = '() values ()'
+
+    constructor (client, builder, bindings) {
+      super(client, builder, bindings)
+      const { returning } = this.single
+
+      if (returning) {
+        this.client.logger.warn(
+          '.returning() is not supported by Clickhouse and will not have any effect.'
+        )
+      }
+    }
+
+    // Update method, including joins, wheres, order & limits.
+    /*
+    update () {
+      const { tableName } = this
+      const updateData = this._prepUpdate(this.single.update)
+      const wheres = this.where()
+      return `ALTER TABLE ${tableName} UPDATE ` +
+        updateData.join(', ') +
+        (wheres ? ` ${wheres}` : '') + ' SETTINGS mutations_sync = 1'
+    }
+    */
+
+    // Compiles a `columnInfo` query.
+    columnInfo () {
+      const column = this.single.columnInfo
+
+      // The user may have specified a custom wrapIdentifier function in the config. We
+      // need to run the identifiers through that function, but not format them as
+      // identifiers otherwise.
+      const table = this.client.customWrapIdentifier(this.single.table, identity)
+
+      return {
+        sql:
+          'select * from information_schema.columns where table_name = ? and table_schema = ?',
+        bindings: [table, this.client.database()],
+        output (resp) {
+          const out = resp.reduce(function r (columns, val) {
+            columns[val.COLUMN_NAME] = {
+              defaultValue: val.COLUMN_DEFAULT,
+              type: val.DATA_TYPE,
+              maxLength: val.CHARACTER_MAXIMUM_LENGTH,
+              nullable: val.IS_NULLABLE === 'YES'
+            }
+            return columns
+          }, {})
+          return (column && out[column]) || out
+        }
+      }
+    }
+
+    limit () {
+      // Workaround for offset only.
+      // see: http://stackoverflow.com/questions/255517/mysql-offset-infinite-rows
+      if (this.single.offset && !this.single.limit && this.single.limit !== 0) return 'limit 18446744073709551615'
+
+      return super.limit()
+    }
+  }
+
+  // Set the QueryBuilder & QueryCompiler on the client object,
+  // in case anyone wants to modify things to suit their own purposes.
+  return QueryCompilerClickhouse
+}
+
+export default factory

package/lib/dialect/schema/columncompiler.js

@@ -0,0 +1,112 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/schema/columncompiler.js
+
+async function factory () {
+  const { importModule } = this.app.bajo
+
+  const ColumnCompiler = await importModule('doboKnex:node_modules/knex/lib/schema/columncompiler.js')
+  const { toNumber } = await importModule('doboKnex:node_modules/knex/lib/util/helpers.js')
+  const Raw = await importModule('doboKnex:node_modules/knex/lib/raw.js')
+
+  class ColumnCompilerClickHouse extends ColumnCompiler {
+    modifiers = ['defaultTo']
+
+    increments = 'UUID default generateUUIDv7()'
+
+    bigincrements = 'UUID default generateUUIDv7()'
+
+    smallint = 'Int8'
+
+    mediumint = 'Int16'
+
+    integer = 'Int32'
+
+    bigint = 'Int64'
+
+    text = 'String'
+
+    varchar = 'String'
+
+    datetime = 'datetime'
+
+    timestamp = 'datetime'
+
+    time = 'time'
+
+    /*
+    double (precision, scale) {
+      return `Decimal32(${toNumber(precision, 8)}, ${toNumber(scale, 2)})`
+    }
+    */
+
+    float = 'Float32'
+
+    double = 'Float64'
+
+    enu (allowed) {
+      // todo
+      // let enumData = [];
+      // allowed.forEach((v, k) => {
+      //     enumData += '';
+      // });
+      return `enum('${allowed.join('\', \'')}')`
+    }
+
+    bit (length) {
+      return length ? `bit(${toNumber(length)})` : 'bit'
+    }
+
+    binary (length) {
+      return length ? `varbinary(${toNumber(length)})` : 'blob'
+    }
+
+    json () {
+      return 'json'
+    }
+
+    jsonb () {
+      return 'json'
+    }
+
+    // Modifiers
+    // ------
+
+    defaultTo (value) {
+      if (value === null || value === undefined) {
+        return ''
+      }
+      if (value instanceof Raw) {
+        value = value.toQuery()
+      } else if (this.type === 'bool' || this.type === 'UInt8') {
+        if (value === 'false') value = 0
+        value = value ? 1 : 0
+      } else {
+        value = this.client._escapeBinding(value.toString())
+      }
+      return 'default ' + value
+    }
+
+    unsigned () {
+      return ''
+    }
+
+    comment () {
+      return ''
+    }
+
+    first () {
+      return ''
+    }
+
+    after (column) {
+      return `after ${this.formatter.wrap(column)}`
+    }
+
+    collate (collation) {
+      return collation && `collate '${collation}'`
+    }
+  }
+
+  return ColumnCompilerClickHouse
+}
+
+export default factory

package/lib/dialect/schema/compiler.js

@@ -0,0 +1,47 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/schema/compiler.js
+
+async function factory () {
+  const { importModule } = this.app.bajo
+  const SchemaCompiler = await importModule('doboKnex:node_modules/knex/lib/schema/compiler.js')
+
+  class SchemaCompilerClickHouse extends SchemaCompiler {
+    // Rename a table on the schema.
+    renameTable (tableName, to) {
+      this.pushQuery(
+        `rename table ${this.formatter.wrap(tableName)} to ${this.formatter.wrap(to)}`
+      )
+    }
+
+    // Check whether a table exists on the query.
+    hasTable (tableName) {
+      const sql = 'select name from system.tables where name = ? and database = currentDatabase()'
+      const bindings = [tableName]
+
+      this.pushQuery({
+        sql,
+        bindings,
+        output: function output (resp) {
+          return resp.length > 0
+        }
+      })
+    }
+
+    // Check whether a column exists on the schema.
+    hasColumn (tableName, column) {
+      const sql = 'SELECT name FROM system.columns where table = ? and name = ? and database = currentDatabase()'
+      const bindings = [tableName, column]
+
+      this.pushQuery({
+        sql,
+        bindings,
+        output: function output (resp) {
+          return resp.length > 0
+        }
+      })
+    }
+  }
+
+  return SchemaCompilerClickHouse
+}
+
+export default factory

package/lib/dialect/schema/tablecompiler.js

@@ -0,0 +1,248 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/schema/tablecompiler.js
+
+async function factory () {
+  const { importModule } = this.app.bajo
+  const { isString, isPlainObject } = this.app.lib._
+  const TableCompiler = await importModule('doboKnex:node_modules/knex/lib/schema/tablecompiler.js')
+  // Table Compiler
+  // ------
+
+  class TableCompilerClickHouse extends TableCompiler {
+    addColumnsPrefix = 'add '
+    alterColumnsPrefix = 'modify '
+    dropColumnPrefix = 'drop '
+
+    createQuery (columns, ifNot) {
+      const createStatement = ifNot ? 'create table if not exists ' : 'create table '
+      let sql = createStatement + this.tableName() + ' (' + columns.sql.join(', ') + ')'
+
+      const engine = this.single.engine || 'TinyLog'
+
+      if (engine) sql += ` engine = ${engine}`
+
+      // hack: find primary key statement and put it here
+      const primary = this.tableBuilder._statements.find(stmt => stmt.grouping === 'alterTable' && stmt.method === 'primary')
+      if (primary && !['TinyLog'].includes(engine)) {
+        sql += ` primary key (${this.formatter.columnize(primary.args[0])})`
+      }
+
+      if (this.single.comment) {
+        const comment = this.single.comment || ''
+        if (comment.length > 60) this.client.logger.warn('The max length for a table comment is 60 characters')
+        sql += ` comment = '${comment}'`
+      }
+
+      sql += ' SETTINGS enable_block_number_column = 1, enable_block_offset_column = 1'
+      this.pushQuery(sql)
+    }
+
+    // Compiles the comment on the table.
+    comment (comment) {
+      this.pushQuery(`alter table ${this.tableName()} comment = '${comment}'`)
+    }
+
+    changeType () {
+      // alter table + table + ' modify ' + wrapped + '// type';
+    }
+
+    // Renames a column on the table.
+    renameColumn (from, to) {
+      const compiler = this
+      const table = this.tableName()
+      const wrapped = this.formatter.wrap(from) + ' ' + this.formatter.wrap(to)
+
+      this.pushQuery({
+        sql:
+          `show fields from ${table} where field = ` +
+          this.formatter.parameter(from),
+        output (resp) {
+          const column = resp[0]
+          const runner = this
+          return compiler.getFKRefs(runner)
+            .then(([refs]) => new Promise((resolve, reject) => {
+              try {
+                if (!refs.length) {
+                  resolve()
+                }
+                resolve(compiler.dropFKRefs(runner, refs))
+              } catch (e) {
+                reject(e)
+              }
+            })
+              .then(function f () {
+                let sql = `alter table ${table} change ${wrapped} ${column.Type}`
+
+                if (String(column.Null)
+                  .toUpperCase() !== 'YES') {
+                  sql += ' NOT NULL'
+                } else {
+                  // This doesn't matter for most cases except Timestamp, where this is important
+                  sql += ' NULL'
+                }
+                if (column.Default) {
+                  sql += ` DEFAULT '${column.Default}'`
+                }
+
+                return runner.query({
+                  sql
+                })
+              })
+              .then(function f () {
+                if (!refs.length) {
+                  return undefined
+                }
+                return compiler.createFKRefs(
+                  runner,
+                  refs.map(function m (ref) {
+                    if (ref.REFERENCED_COLUMN_NAME === from) {
+                      ref.REFERENCED_COLUMN_NAME = to
+                    }
+                    if (ref.COLUMN_NAME === from) {
+                      ref.COLUMN_NAME = to
+                    }
+                    return ref
+                  })
+                )
+              }))
+        }
+      })
+    }
+
+    getFKRefs (runner) {
+      // todo wtf?
+      const formatter = this.client.formatter(this.tableBuilder)
+      const sql = `SELECT KCU.CONSTRAINT_NAME, KCU.TABLE_NAME, KCU.COLUMN_NAME,
+          KCU.REFERENCED_TABLE_NAME, KCU.REFERENCED_COLUMN_NAME,
+          RC.UPDATE_RULE,
+          RC.DELETE_RULE FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS KCU JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS RC
+          USING(CONSTRAINT_NAME)WHERE KCU.REFERENCED_TABLE_NAME = ${formatter.parameter(this.tableNameRaw)}   AND KCU.CONSTRAINT_SCHEMA = ${formatter.parameter(this.client.database())}   AND RC.CONSTRAINT_SCHEMA = ${formatter.parameter(this.client.database())}`
+
+      return runner.query({
+        sql,
+        bindings: formatter.bindings
+      })
+    }
+
+    dropFKRefs (runner, refs) {
+      const formatter = this.client.formatter(this.tableBuilder)
+
+      return Promise.all(
+        refs.map(function f (ref) {
+          const constraintName = formatter.wrap(ref.CONSTRAINT_NAME)
+          const tableName = formatter.wrap(ref.TABLE_NAME)
+          return runner.query({
+            sql: `alter table ${tableName} drop foreign key ${constraintName}`
+          })
+        })
+      )
+    }
+
+    createFKRefs (runner, refs) {
+      const formatter = this.client.formatter(this.tableBuilder)
+
+      return Promise.all(
+        refs.map(function f (ref) {
+          const tableName = formatter.wrap(ref.TABLE_NAME)
+          const keyName = formatter.wrap(ref.CONSTRAINT_NAME)
+          const column = formatter.columnize(ref.COLUMN_NAME)
+          const references = formatter.columnize(ref.REFERENCED_COLUMN_NAME)
+          const inTable = formatter.wrap(ref.REFERENCED_TABLE_NAME)
+          const onUpdate = ` ON UPDATE ${ref.UPDATE_RULE}`
+          const onDelete = ` ON DELETE ${ref.DELETE_RULE}`
+
+          return runner.query({
+            sql:
+              `alter table ${tableName} add constraint ${keyName} ` +
+              'foreign key (' +
+              column +
+              ') references ' +
+              inTable +
+              ' (' +
+              references +
+              ')' +
+              onUpdate +
+              onDelete
+          })
+        })
+      )
+    }
+
+    index (columns, indexName, options) {
+      let indexType
+
+      if (isString(options)) {
+        indexType = options
+      } else if (isPlainObject(options)) {
+        ({ indexType } = options)
+      }
+      if (!indexType) indexType = 'bloom_filter'
+
+      indexName = indexName
+        ? this.formatter.wrap(indexName)
+        : this._indexCommand('index', this.tableNameRaw, columns)
+      this.pushQuery(
+        `alter table ${this.tableName()} add index ${indexName}(${this.formatter.columnize(columns)}) type ${indexType}`
+      )
+    }
+
+    primary (columns, constraintName) {
+      // these won't work since primary key needs to be defined inside create table
+      /*
+      constraintName = constraintName
+        ? this.formatter.wrap(constraintName)
+        : this.formatter.wrap(`${this.tableNameRaw}_pkey`)
+      this.pushQuery(
+        `alter table ${this.tableName()} add primary key ${constraintName}(${this.formatter.columnize(
+          columns
+        )})`
+      )
+      */
+    }
+
+    unique (columns, indexName) {
+      indexName = indexName
+        ? this.formatter.wrap(indexName)
+        : this._indexCommand('unique', this.tableNameRaw, columns)
+      this.pushQuery(
+        `alter table ${this.tableName()} add unique ${indexName}(${this.formatter.columnize(
+          columns
+        )})`
+      )
+    }
+
+    // Compile a drop index command.
+    dropIndex (columns, indexName) {
+      indexName = indexName
+        ? this.formatter.wrap(indexName)
+        : this._indexCommand('index', this.tableNameRaw, columns)
+      this.pushQuery(`alter table ${this.tableName()} drop index ${indexName}`)
+    }
+
+    // Compile a drop foreign key command.
+    dropForeign (columns, indexName) {
+      indexName = indexName
+        ? this.formatter.wrap(indexName)
+        : this._indexCommand('foreign', this.tableNameRaw, columns)
+      this.pushQuery(
+        `alter table ${this.tableName()} drop foreign key ${indexName}`
+      )
+    }
+
+    // Compile a drop primary key command.
+    dropPrimary () {
+      // this.pushQuery(`alter table ${this.tableName()} drop primary key`)
+    }
+
+    // Compile a drop unique key command.
+    dropUnique (column, indexName) {
+      indexName = indexName
+        ? this.formatter.wrap(indexName)
+        : this._indexCommand('unique', this.tableNameRaw, column)
+      this.pushQuery(`alter table ${this.tableName()} drop index ${indexName}`)
+    }
+  }
+
+  return TableCompilerClickHouse
+}
+
+export default factory

package/lib/dialect/transaction.js

@@ -0,0 +1,30 @@
+// From: https://github.com/DnAp/KnexClickhouseDialect/blob/master/src/transaction.js
+
+/**
+ * @implements {Knex.Transaction}
+ */
+class TransactionClickHouse {
+  executionPromise = Promise.resolve(undefined)
+
+  commit (value) {
+    return undefined
+  }
+
+  isCompleted () {
+    return true
+  }
+
+  query (conn, sql, status, value) {
+    return undefined
+  }
+
+  rollback () {
+    return undefined
+  }
+
+  savepoint (transactionScope) {
+    return undefined
+  }
+}
+
+export default TransactionClickHouse

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "dobo-clickhouse",
+  "version": "2.2.1",
+  "description": "Clickhouse driver for Dobo",
+  "main": "index.js",
+  "scripts": {
+    "build-doc": "jsdoc -c .jsdoc.conf.json",
+    "test": "mocha"
+  },
+  "type": "module",
+  "bajo": {
+    "type": "plugin",
+    "alias": "dbclickhouse",
+    "dependencies": ["dobo", "dobo-knex"]
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ardhi/dobo-clickhouse.git"
+  },
+  "keywords": [
+    "clickhouse",
+    "dobo",
+    "db",
+    "driver",
+    "bajo",
+    "framework",
+    "modular"
+  ],
+  "author": "Ardhi Lukianto <ardhi@lukianto.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ardhi/dobo-clickhouse/issues"
+  },
+  "homepage": "https://github.com/ardhi/dobo-clickhouse#readme",
+  "devDependencies": {
+    "clean-jsdoc-theme": "^4.3.0",
+    "jsdoc-plugin-intersection": "^1.0.4"
+  },
+  "dependencies": {
+    "clickhouse": "^2.6.0",
+    "sqlstring": "^2.3.3"
+  }
+}

package/wiki/CHANGES.md

@@ -0,0 +1,6 @@
+# Changes
+
+## 2026-01-19
+
+- [2.2.0] First published version
+