knex-dm 1.0.34946

package/LICENSE

@@ -0,0 +1,22 @@
+软件产品授权证书
+
+重要须知：武汉达梦数据库有限公司提醒您请在安装该软件之前仔细阅读以下许可协议。您一旦安装、下载、访问或以其他方式使用该软件产品，即表明您同意接受本《协议》各条款约束。如果您同意访问该软件产品，请选择“接受”项。如果您不同意本《协议》中的条款，请不要安装、访问或使用该软件产品；但您可将其退回。如果您已访问了该软件产品，请点击“不接受”项，并退出该安装程序。
+
+1.本软件的使用、武汉达梦数据库有限公司提供的服务均按照所签订合约来执行。
+
+2.本软件版权为武汉达梦数据库有限公司所有，您不能对本软件的任何部分进行修改、分解、反汇编和反编译。
+
+3.本软件是已经注册登记并受法律保护的商业软件。它的适用法律包括《中华人民共和国计算机保护法》、《中华人民共和国著作权法》、《中华人民共和国专利法》等。
+
+4.不得将本软件转让给他方使用，否则视为违反合约。
+
+Dameng Database co., ltd.
+
+Software License Agreement
+
+READ THE TERMS OF THIS AGREEMENT AND ANY PROVIDED SUPPLEMENTAL LICENSE TERMS (COLLECTIVELY "AGREEMENT") CAREFULLY BEFORE OPENING THE SOFTWARE MEDIA PACKAGE.  BY OPENING THE SOFTWARE MEDIA PACKAGE, YOU AGREE TO THE TERMS OF THIS AGREEMENT.  IF YOU ARE ACCESSING THE SOFTWARE ELECTRONICALLY, INDICATE YOUR ACCEPTANCE OF THESE TERMS BY SELECTING THE "ACCEPT" BUTTON AT THE END OF THIS AGREEMENT.IF YOU DO NOT AGREE TO ALL OF THESE TERMS, PROMPTLY RETURN THE UNUSED SOFTWARE TO YOUR PLACE OF PURCHASE FOR A REFUNDOR, IF THE SOFTWARE IS ACCESSED ELECTRONICALLY, SELECT THE "NOT ACCEPT" BUTTON AT THE END OF THIS AGREEMENT AND THE INSTALLATION PROCESS WILL NOT CONTINUE.
+
+1. The use and the services of the software shall remain in the agreement.
+2. DM Database owns all copyrights in the product. You may not modify, decompose, compile, and decompile the product.
+3. The product is registered and protected by PRC copyright and other laws. 
+4. You may not allow third parties to access or use the product.

package/README.md

@@ -0,0 +1,50 @@
+# knex-dm
+
+此包为达梦数据库驱动 [dmdb](https://www.npmjs.com/package/dmdb) 适配 [knex](https://www.npmjs.com/package/knex) 框架的方言包，使用示例如下：
+
+```js
+const knex = require('knex')({
+    client: require('knex-dm'),
+    connection: {
+        // 其他可配置的内容见dmdb.ConnectionAttributes
+        connectString: 'localhost:5236',
+        user: 'SYSDBA',
+        password: 'SYSDBA',
+        schema: 'SYSDBA1',
+    },
+    debug: false,
+});
+await knex.schema.createTable('USERS', (table) => {
+    table.increments('ID');
+    table.string('USER_NAME');
+});
+await knex('USERS').insert({"USER_NAME": "Tom"});
+await knex.destroy();
+```
+
+## 方言包扩展内容
+
+### 配置项 - fetchAsString
+指定结果集中的一些数据类型以字符串形式返回，fetchAsString数组的可选值为：'DATE', 'NUMBER', 'BUFFER', 'CLOB'。
+```JS
+const knex = require('knex')({
+    client: require('knex-dm'),
+    connection: {
+        /*...*/
+    },
+    fetchAsString: ['number', 'clob'],
+});
+```
+
+### 自增列插入
+**knex(tableName, options={identityInsert: boolean})**  
+**identityInsert**: 是否开启自增列插入。由于达梦数据库不支持往自增列中手动插入值，此选项通过在插入语句前添加`set identity_insert <table> on;`语句以实现手动插入自增列的功能。
+```js
+knex('test').insert({id: 1}) // 报错：[-2723] 仅当指定列列表，且SET IDENTITY_INSERT为ON时，才能对自增列赋值
+knex('test', {identityInsert: true}).insert({id: 1}) // 执行成功
+```
+
+## Change Logs
+
+### knex-dm v1.0.34946(2025-04-07)
+- 发布正式版，已跑通knex源码测例，主要以兼容ORACLE为主

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "knex-dm",
+  "version": "1.0.34946",
+  "description": "DM database dialect for knex.js",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Dameng Database",
+  "dependencies": {
+    "dmdb": "^1.0.34946",
+    "lodash": "^4.17.21"
+  },
+  "peerDependencies": {
+    "knex": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=16"
+  }
+}

package/src/index.js

@@ -0,0 +1,360 @@
+// DM Client
+// -------
+const each = require('lodash/each');
+const flatten = require('lodash/flatten');
+const isEmpty = require('lodash/isEmpty');
+const map = require('lodash/map');
+const Client = require('knex/lib/client');
+const Formatter = require('knex/lib/formatter');
+const { isString } = require('knex/lib/util/is');
+const { outputQuery, unwrapRaw } = require('knex/lib/formatter/wrappingFormatter');
+const { compileCallback } = require('knex/lib/formatter/formatterUtils');
+
+const QueryBuilder = require('./query/dmdb-querybuilder');
+const QueryCompiler = require('./query/dmdb-querycompiler');
+const SchemaCompiler = require('./schema/dmdb-compiler');
+const TableCompiler = require('./schema/dmdb-tablecompiler');
+const ColumnBuilder = require('./schema/dmdb-columnbuilder');
+const ColumnCompiler = require('./schema/dmdb-columncompiler');
+const {
+  BlobHelper,
+  ReturningHelper,
+  isConnectionError,
+  monkeyPatchConnection,
+} = require('./utils');
+const ViewCompiler = require('./schema/dmdb-viewcompiler');
+const ViewBuilder = require('./schema/dmdb-viewbuilder');
+const Transaction = require('./transaction');
+
+class Client_DM extends Client {
+  constructor(config) {
+    super(config);
+
+    if (this.driver) {
+      process.env.UV_THREADPOOL_SIZE = process.env.UV_THREADPOOL_SIZE || 1;
+      process.env.UV_THREADPOOL_SIZE =
+        parseInt(process.env.UV_THREADPOOL_SIZE) + this.driver.poolMax;
+    }
+  }
+
+  _driver() {
+    const client = this;
+    const dmdb = require('dmdb');
+    client.fetchAsString = [];
+    if (this.config.fetchAsString && Array.isArray(this.config.fetchAsString)) {
+      this.config.fetchAsString.forEach(function (type) {
+        if (!isString(type)) return;
+        type = type.toUpperCase();
+        if (dmdb[type]) {
+          if (
+            type !== 'NUMBER' &&
+            type !== 'DATE' &&
+            type !== 'CLOB' &&
+            type !== 'BUFFER'
+          ) {
+            this.logger.warn(
+              'Only "date", "number", "clob" and "buffer" are supported for fetchAsString'
+            );
+          }
+          client.fetchAsString.push(dmdb[type]);
+        }
+      });
+    }
+
+    client.parseJson = this.config.parseJson !== false;
+    return dmdb;
+  }
+
+  schemaCompiler() {
+    return new SchemaCompiler(this, ...arguments);
+  }
+
+  queryBuilder() {
+    return new QueryBuilder(this);
+  }
+
+  queryCompiler(builder, formatter) {
+    return new QueryCompiler(this, builder, formatter);
+  }
+
+  tableCompiler() {
+    return new TableCompiler(this, ...arguments);
+  }
+
+  columnBuilder() {
+    return new ColumnBuilder(this, ...arguments);
+  }
+
+  columnCompiler() {
+    return new ColumnCompiler(this, ...arguments);
+  }
+
+  viewBuilder() {
+    return new ViewBuilder(this, ...arguments);
+  }
+
+  viewCompiler() {
+    return new ViewCompiler(this, ...arguments);
+  }
+
+  formatter(builder) {
+    return new Formatter(this, builder);
+  }
+
+  transaction() {
+    return new Transaction(this, ...arguments);
+  }
+
+  prepBindings(bindings) {
+    return map(bindings, (value) => {
+      if (value instanceof BlobHelper && this.driver) {
+        return { type: this.driver.BLOB, dir: this.driver.BIND_OUT };
+        // Returning helper always use ROWID as string
+      } else if (value instanceof ReturningHelper && this.driver) {
+        return { type: this.driver.STRING, dir: this.driver.BIND_OUT };
+      } else if (typeof value === 'boolean') {
+        return value ? 1 : 0;
+      }
+      return value;
+    });
+  }
+
+  // Checks whether a value is a function... if it is, we compile it
+  // otherwise we check whether it's a raw
+  parameter(value, builder, formatter) {
+    if (typeof value === 'function') {
+      return outputQuery(
+        compileCallback(value, undefined, this, formatter),
+        true,
+        builder,
+        this
+      );
+    } else if (value instanceof BlobHelper) {
+      formatter.bindings.push(value.value);
+      return '?';
+    }
+    return unwrapRaw(value, true, builder, this, formatter) || '?';
+  }
+
+  // Position the bindings for the query.
+  positionBindings(sql) {
+    let questionCount = 0;
+    return sql.replace(/\?/g, function () {
+      questionCount += 1;
+      return `:${questionCount}`;
+    });
+  }
+
+  _stream(connection, obj, stream, options) {
+    if (!obj.sql) throw new Error('The query is empty');
+
+    return new Promise(function (resolver, rejecter) {
+      stream.on('error', (err) => {
+        if (isConnectionError(err)) {
+          connection.__knex__disposed = err;
+        }
+        rejecter(err);
+      });
+      stream.on('end', resolver);
+      const queryStream = connection.queryStream(
+        obj.sql,
+        obj.bindings,
+        options
+      );
+      queryStream.pipe(stream);
+      queryStream.on('error', function (error) {
+        rejecter(error);
+        stream.emit('error', error);
+      });
+    });
+  }
+
+  alias(first, second) {
+    return first + ' ' + second;
+  }
+
+  // Get a raw connection, called by the `pool` whenever a new
+  // connection needs to be added to the pool.
+  acquireRawConnection() {
+    return new Promise((resolver, rejecter) => {
+      this.driver.fetchAsString = this.fetchAsString;
+      this.driver.parseJson = this.parseJson;
+
+      this.driver.getConnection(this.connectionSettings, (err, connection) => {
+        if (err) {
+          return rejecter(err);
+        }
+        monkeyPatchConnection(connection, this);
+
+        resolver(connection);
+      });
+    });
+  }
+
+  // Used to explicitly close a connection, called internally by the pool
+  // when a connection times out or the pool is shutdown.
+  destroyRawConnection(connection) {
+    return connection.release();
+  }
+
+  // Runs the query on the specified connection, providing the bindings
+  // and any other necessary prep work.
+  _query(connection, obj) {
+    if (!obj.sql) throw new Error('The query is empty');
+
+    const options = Object.assign({}, obj.options, { autoCommit: false });
+    if (obj.method === 'select') {
+      options.resultSet = true;
+    }
+    return connection
+      .executeAsync(obj.sql, obj.bindings, options)
+      .then(async function (response) {
+        // Flatten outBinds
+        let outBinds = flatten(response.outBinds);
+        obj.response = response.rows || [];
+        obj.rowsAffected = response.rows
+          ? response.rows.rowsAffected
+          : response.rowsAffected;
+
+        //added for outBind parameter
+        if (obj.method === 'raw' && outBinds.length > 0) {
+          return {
+            response: outBinds,
+          };
+        }
+
+        if (obj.method === 'update') {
+          const modifiedRowsCount = obj.rowsAffected.length || obj.rowsAffected;
+          const updatedObjOutBinding = [];
+          const updatedOutBinds = [];
+          const updateOutBinds = (i) =>
+            function (value, index) {
+              const OutBindsOffset = index * modifiedRowsCount;
+              updatedOutBinds.push(outBinds[i + OutBindsOffset]);
+            };
+
+          for (let i = 0; i < modifiedRowsCount; i++) {
+            updatedObjOutBinding.push(obj.outBinding[0]);
+            each(obj.outBinding[0], updateOutBinds(i));
+          }
+          outBinds = updatedOutBinds;
+          obj.outBinding = updatedObjOutBinding;
+        }
+
+        if (!obj.returning && outBinds.length === 0) {
+          if (!connection.isTransaction) {
+            await connection.commitAsync();
+          }
+          return obj;
+        }
+        const rowIds = [];
+        let offset = 0;
+
+        for (let line = 0; line < obj.outBinding.length; line++) {
+          const ret = obj.outBinding[line];
+
+          offset =
+            offset +
+            (obj.outBinding[line - 1] ? obj.outBinding[line - 1].length : 0);
+
+          for (let index = 0; index < ret.length; index++) {
+            const out = ret[index];
+
+            await new Promise(function (bindResolver, bindRejecter) {
+              if (out instanceof BlobHelper) {
+                const blob = outBinds[index + offset];
+                if (out.returning) {
+                  obj.response[line] = obj.response[line] || {};
+                  obj.response[line][out.columnName] = out.value;
+                }
+                blob.on('error', function (err) {
+                  bindRejecter(err);
+                });
+                blob.on('finish', function () {
+                  bindResolver();
+                });
+                blob.write(out.value);
+                blob.end();
+              } else if (obj.outBinding[line][index] === 'ROWID') {
+                rowIds.push(outBinds[index + offset]);
+                bindResolver();
+              } else {
+                obj.response[line] = obj.response[line] || {};
+                obj.response[line][out] = outBinds[index + offset];
+                bindResolver();
+              }
+            });
+          }
+        }
+        if (obj.returningSql) {
+          const response = await connection.executeAsync(
+            obj.returningSql(),
+            rowIds,
+            { resultSet: true }
+          );
+          obj.response = response.rows;
+        }
+        if (connection.isTransaction) {
+          return obj;
+        }
+        await connection.commitAsync();
+        return obj;
+      });
+  }
+
+  // Process the response as returned from the query.
+  processResponse(obj, runner) {
+    const { response } = obj;
+    if (obj.output) {
+      return obj.output.call(runner, response);
+    }
+    switch (obj.method) {
+      case 'select':
+        return response;
+      case 'first':
+        return response[0];
+      case 'pluck':
+        return map(response, obj.pluck);
+      case 'insert':
+      case 'del':
+      case 'update':
+      case 'counter':
+        if ((obj.returning && !isEmpty(obj.returning)) || obj.returningSql) {
+          return response;
+        } else if (obj.rowsAffected !== undefined) {
+          return obj.rowsAffected;
+        } else {
+          return 1;
+        }
+      default:
+        return response;
+    }
+  }
+
+  processPassedConnection(connection) {
+    monkeyPatchConnection(connection, this);
+  }
+}
+
+function resolveConnectString(connectionSettings) {
+  if (connectionSettings.connectString) {
+    return connectionSettings.connectString;
+  }
+
+  if (!connectionSettings.port) {
+    return connectionSettings.host + '/' + connectionSettings.database;
+  }
+
+  return (
+    connectionSettings.host +
+    ':' +
+    connectionSettings.port +
+    '/' +
+    connectionSettings.database
+  );
+}
+
+Client_DM.prototype.dialect = 'dmdb';
+Client_DM.prototype.driverName = 'dmdb';
+
+module.exports = Client_DM;

package/src/query/dmdb-querybuilder.js

@@ -0,0 +1,20 @@
+const QueryBuilder = require('knex/lib/query/querybuilder');
+
+class QueryBuilder_DM extends QueryBuilder {
+  // Sets the `tableName` on the query.
+  // Alias to "from" for select and "into" for insert statements
+  // e.g. builder.insert({a: value}).into('tableName')
+  // `options`: options object containing keys:
+  //   - `only`: whether the query should use SQL's ONLY to not return
+  //           inheriting table data. Defaults to false.
+  //   - `identityInsert`: 是否开启自增列插入，自动在insert语句前添加
+  //           set IDENTITY_INSERT <tableName> on ;
+  table(tableName, options = {}) {
+    this._single.table = tableName;
+    this._single.only = options.only === true;
+    this._single.identityInsert = options.identityInsert === true;
+    return this;
+  }
+};
+
+module.exports = QueryBuilder_DM