hana-kgvector 0.1.3 → 0.1.4

package/dist/chunk-I3F3SOHM.js

@@ -1,726 +0,0 @@
-import {
-  __commonJS,
-  __require
-} from "./chunk-VUNV25KB.js";
-
-// node_modules/.pnpm/@sap+hana-client@2.27.19/node_modules/@sap/hana-client/extension/Stream.js
-var require_Stream = __commonJS({
-  "node_modules/.pnpm/@sap+hana-client@2.27.19/node_modules/@sap/hana-client/extension/Stream.js"(exports, module) {
-    module.exports = {
-      // Create an readable stream which returns object
-      createObjectStream: function(resultset) {
-        return new HanaRSStream(resultset, false);
-      },
-      // Create an readable stream which returns array
-      createArrayStream: function(resultset) {
-        return new HanaRSStream(resultset, true);
-      },
-      // Create a LOB stream
-      createLobStream: function(resultset, columnIndex, options) {
-        return new HanaLobStream(resultset, columnIndex, options);
-      },
-      // Create a LOB stream for a LOB output parameter
-      createParameterLobStream: function(statement, paramIndex, options) {
-        return new HanaParameterLobStream(statement, paramIndex, options);
-      },
-      // Create a statement which allows user to pass readable streams for input parameters
-      createStatement: function(connection, sql, callback) {
-        return new HanaStatement(connection, sql, callback);
-      },
-      // Create a statement for procedure call. After calling exec, output parameters
-      // (err, scalarParams, table1, table2...) will be passed to the callback
-      createProcStatement: function(connection, sql, callback) {
-        return new HanaProcStatement(connection, sql, callback);
-      },
-      // Execute a statement which returns multiple resultsets. After calling this method, output parameters
-      // (err, scalarParams, table1, table2..., columnInfo1, columnInfo2...) will be passed to the callback
-      executeMultipleResultSets: function(...args2) {
-        if (args2.length != 4 && args2.length != 5) {
-          throw new Error("Invalid number of parameters - executeMultipleResultSets(connection, sql, params, [options,] callback).");
-        }
-        var connection = args2[0];
-        var sql = args2[1];
-        var params = args2[2];
-        if (args2.length == 4) {
-          var options = {};
-          var callback = args2[3];
-        } else if (args2.length == 5) {
-          var options = args2[3];
-          var callback = args2[4];
-        }
-        if (callback == void 0 || callback == null || typeof callback !== "function") {
-          throw new Error("Invalid parameter 'callback'.");
-        }
-        var statement = new HanaProcStatement(connection, sql, function(err2, stmt) {
-          if (err2) {
-            callback(err2);
-          } else {
-            let s = stmt;
-            stmt.exec(params, options, function(err3, ...args3) {
-              if (!err3) {
-                s.getColumnInfo().forEach(function(ci) {
-                  args3.push(ci);
-                });
-              }
-              s.drop(function(errDrop) {
-                if (err3) {
-                  callback(err3);
-                } else if (errDrop) {
-                  callback(errDrop);
-                } else {
-                  args3.unshift(void 0);
-                  callback.apply(null, args3);
-                }
-              });
-            });
-          }
-        });
-      }
-    };
-    var util = __require("util");
-    var streamModule = __require("stream");
-    var Stream = streamModule.Stream;
-    var Readable = streamModule.Readable;
-    function HanaRSStream(resultset, asArray) {
-      checkParameter("resultset", resultset);
-      Readable.call(this, { objectMode: true });
-      resultset.setAsArrayDefault(asArray);
-      this.resultset = resultset;
-    }
-    util.inherits(HanaRSStream, Readable);
-    HanaRSStream.prototype._read = function() {
-      var stream = this;
-      if (this.resultset.nextCanBlock()) {
-        this.resultset.next(function(err2, ret2) {
-          if (err2 === void 0) {
-            if (ret2) {
-              if (stream.resultset.getValuesCanBlock()) {
-                stream.resultset.getValues(function(err3, ret3) {
-                  if (err3 === void 0) {
-                    stream.push(ret3);
-                  } else {
-                    stream.emit("error", err3);
-                  }
-                });
-              } else {
-                try {
-                  stream.push(stream.resultset.getValues());
-                } catch (err3) {
-                  stream.emit("error", err3);
-                }
-              }
-            } else {
-              stream.push(null);
-            }
-          } else {
-            stream.emit("error", err2);
-          }
-        });
-      } else {
-        try {
-          var ret = this.resultset.next();
-          if (ret) {
-            stream.push(stream.resultset.getValues());
-          } else {
-            stream.push(null);
-          }
-        } catch (err2) {
-          stream.emit("error", err2);
-        }
-      }
-    };
-    HanaRSStream.prototype._destroy = function(error, callback) {
-      this.push(null);
-      if (typeof callback === "function") {
-        callback(error);
-      }
-    };
-    function HanaLobStream(resultset, columnIndex, options) {
-      checkParameter("resultset", resultset);
-      var opts = getLobStreamOptions(options);
-      Readable.call(this, opts);
-      this.resultset = resultset;
-      this.columnInfo = this.resultset.getColumnInfo();
-      this.columnIndex = columnIndex;
-      checkColumnIndex(this.columnInfo, columnIndex);
-      checkLobType(this.columnInfo, columnIndex);
-      this.isString = this.columnInfo[this.columnIndex].typeName === "STRING";
-      this.offset = 0;
-      this.noPause = opts.noPause;
-      this.valueAsString = false;
-      if (typeof opts.valueAsString === "boolean") {
-        this.valueAsString = opts.valueAsString;
-      }
-    }
-    util.inherits(HanaLobStream, Readable);
-    HanaLobStream.prototype._read = function(bufferSize) {
-      if (this.resultset.isNull(this.columnIndex)) {
-        this.push(null);
-        return;
-      }
-      var stream = this;
-      stream.bufferSize = bufferSize;
-      var buffer = createBuffer(bufferSize);
-      if (!this.noPause) {
-        this.pause();
-      }
-      this.resultset.getData(this.columnIndex, this.offset, buffer, 0, bufferSize, function(err2, bytesRetrieved) {
-        if (err2 === void 0) {
-          if (stream.isString) {
-            if (bytesRetrieved > 0) {
-              let nullChar = buffer.indexOf(0);
-              if (nullChar === 0) {
-                stream.push(null);
-              } else {
-                let newBuffer = buffer;
-                if (nullChar > 0) {
-                  newBuffer = buffer.slice(0, nullChar);
-                }
-                let str = newBuffer.toString("utf8");
-                stream.offset += str.length;
-                if (stream.valueAsString) {
-                  stream.push(str);
-                } else {
-                  stream.push(newBuffer);
-                }
-                if (bytesRetrieved + 3 < stream.bufferSize) {
-                  stream.push(null);
-                }
-              }
-            } else {
-              stream.push(null);
-            }
-          } else {
-            stream.offset += bytesRetrieved;
-            if (bytesRetrieved > 0) {
-              if (bytesRetrieved < stream.bufferSize) {
-                stream.push(buffer.slice(0, bytesRetrieved));
-                stream.push(null);
-              } else {
-                stream.push(buffer);
-              }
-            } else {
-              stream.push(null);
-            }
-          }
-        } else {
-          if (err2.code === 100) {
-            stream.push(null);
-          } else {
-            stream.emit("error", err2);
-          }
-        }
-        if (!stream.noPause) {
-          stream.resume();
-        }
-      });
-    };
-    HanaLobStream.prototype._destroy = function(error, callback) {
-      this.push(null);
-      if (typeof callback === "function") {
-        callback(error);
-      }
-    };
-    function HanaParameterLobStream(statement, paramIndex, options) {
-      checkParameter("statement", statement);
-      var opts = getLobStreamOptions(options);
-      Readable.call(this, opts);
-      this.statement = statement;
-      this.paramInfo = this.statement.getParameterInfo();
-      this.paramIndex = paramIndex;
-      checkParameterIndex(this.paramInfo, paramIndex);
-      checkParameterLobType(this.paramInfo, paramIndex);
-      this.isString = this.paramInfo[this.paramIndex].typeName === "STRING";
-      this.offset = 0;
-      this.noPause = opts.noPause;
-      this.valueAsString = false;
-      if (typeof opts.valueAsString === "boolean") {
-        this.valueAsString = opts.valueAsString;
-      }
-    }
-    util.inherits(HanaParameterLobStream, Readable);
-    HanaParameterLobStream.prototype._read = function(bufferSize) {
-      if (this.statement.isParameterNull(this.paramIndex)) {
-        this.push(null);
-        return;
-      }
-      var stream = this;
-      stream.bufferSize = bufferSize;
-      var buffer = createBuffer(bufferSize);
-      if (!this.noPause) {
-        this.pause();
-      }
-      this.statement.getData(this.paramIndex, this.offset, buffer, 0, bufferSize, function(err2, bytesRetrieved) {
-        if (err2 === void 0) {
-          if (stream.isString) {
-            if (bytesRetrieved > 0) {
-              let nullChar = buffer.indexOf(0);
-              if (nullChar === 0) {
-                stream.push(null);
-              } else {
-                let newBuffer = buffer;
-                if (nullChar > 0) {
-                  newBuffer = buffer.slice(0, nullChar);
-                }
-                let str = newBuffer.toString("utf8");
-                stream.offset += str.length;
-                if (stream.valueAsString) {
-                  stream.push(str);
-                } else {
-                  stream.push(newBuffer);
-                }
-                if (bytesRetrieved < stream.bufferSize) {
-                  stream.push(null);
-                }
-              }
-            } else {
-              stream.push(null);
-            }
-          } else {
-            stream.offset += bytesRetrieved;
-            if (bytesRetrieved > 0) {
-              if (bytesRetrieved < stream.bufferSize) {
-                stream.push(buffer.slice(0, bytesRetrieved));
-                stream.push(null);
-              } else {
-                stream.push(buffer);
-              }
-            } else {
-              stream.push(null);
-            }
-          }
-        } else {
-          if (err2.code === 100) {
-            stream.push(null);
-          } else {
-            stream.emit("error", err2);
-          }
-        }
-        if (!stream.noPause) {
-          stream.resume();
-        }
-      });
-    };
-    HanaParameterLobStream.prototype._destroy = function(error, callback) {
-      this.push(null);
-      if (typeof callback === "function") {
-        callback(error);
-      }
-    };
-    function HanaStatement(connection, sql, callback) {
-      if (connection === void 0 || connection === null) {
-        handleError("Invalid parameter 'connection'.", callback);
-        return;
-      }
-      if (sql === void 0 || sql === null) {
-        handleError("Invalid parameter 'sql'.", callback);
-        return;
-      }
-      this.connection = connection;
-      this.sql = sql;
-      this.stmt = null;
-      this.result = 0;
-      if (callback) {
-        var hanaStmt2 = this;
-        this.connection.prepare(sql, function(err2, stmt) {
-          hanaStmt2.stmt = stmt;
-          callback(err2, hanaStmt2);
-        });
-      } else {
-        this.stmt = this.connection.prepare(sql);
-      }
-    }
-    HanaStatement.prototype.getStatement = function() {
-      return this.stmt;
-    };
-    HanaStatement.prototype.drop = function(callback) {
-      if (this.stmt) {
-        var stmt = this.stmt;
-        this.stmt = null;
-        stmt.drop(callback);
-      }
-    };
-    HanaStatement.prototype.exec = function(params, callback) {
-      if (callback === void 0 || callback === null || typeof callback !== "function") {
-        throw new Error("Invalid parameter 'callback'.");
-      }
-      if (params === void 0 || params === null || !(params instanceof Array)) {
-        handleError("Invalid parameter 'params'.", callback);
-        return;
-      }
-      if (!this.stmt) {
-        handleError("Invalid statement.", callback);
-        return;
-      }
-      var hasArrayParam = false;
-      var hasNonArrayParam = false;
-      for (var i2 = 0; i2 < params.length; i2++) {
-        if (params[i2] instanceof Array) {
-          hasArrayParam = true;
-        } else {
-          hasNonArrayParam = true;
-        }
-        if (hasArrayParam && hasNonArrayParam) {
-          handleError("Invalid parameter 'params': contains both array and non-array parameters.", callback);
-          return;
-        }
-      }
-      if (params.length === 0) {
-        callback(null, 0);
-        return;
-      }
-      this.callback = callback;
-      this.currentRow = 0;
-      if (hasArrayParam) {
-        this.paramsArray = params;
-      } else {
-        this.paramsArray = [];
-        this.paramsArray.push(params);
-      }
-      this._exec();
-    };
-    HanaStatement.prototype._exec = function() {
-      this.params = this.paramsArray[this.currentRow];
-      var isStream = [];
-      var paramsNew = [];
-      var streamCount = 0;
-      var hanaStmt2 = this;
-      for (var i2 = 0; i2 < this.params.length; i2++) {
-        if (this.params[i2] instanceof Stream) {
-          this.params[i2].pause();
-          isStream.push(true);
-          paramsNew.push({ sendParameterData: true });
-          streamCount++;
-        } else {
-          isStream.push(false);
-          paramsNew.push(this.params[i2]);
-        }
-      }
-      if (streamCount <= 0) {
-        this.stmt.exec(paramsNew, function(err2, result) {
-          if (err2) {
-            hanaStmt2.callback(err2, result);
-          } else {
-            hanaStmt2.currentRow++;
-            hanaStmt2.result += result;
-            if (hanaStmt2.currentRow === hanaStmt2.paramsArray.length) {
-              hanaStmt2.callback(null, hanaStmt2.result);
-            } else {
-              hanaStmt2._exec();
-            }
-          }
-        });
-      } else {
-        this.stmt.exec(paramsNew, function(err2, result) {
-          if (err2) {
-            hanaStmt2.callback(err2, result);
-          } else {
-            for (var paramIndex = 0; paramIndex < hanaStmt2.params.length; paramIndex++) {
-              if (hanaStmt2.params[paramIndex] instanceof Stream) {
-                break;
-              }
-            }
-            hanaStmt2.sendParameterData(paramIndex);
-          }
-        });
-      }
-    };
-    HanaStatement.prototype.sendParameterData = function(paramIndex) {
-      var hanaStmt2 = this;
-      this.params[paramIndex].on("error", function(error) {
-        hanaStmt2.callback(error);
-      });
-      this.params[paramIndex].on("end", function() {
-        hanaStmt2.stmt.sendParameterData(paramIndex, null, function(err2) {
-          if (err2) {
-            hanaStmt2.callback(err2);
-          } else {
-            var nextStream = -1;
-            for (var i2 = paramIndex + 1; i2 < hanaStmt2.params.length; i2++) {
-              if (hanaStmt2.params[i2] instanceof Stream) {
-                nextStream = i2;
-                break;
-              }
-            }
-            if (nextStream >= 0) {
-              hanaStmt2.sendParameterData(nextStream);
-            } else {
-              hanaStmt2.currentRow++;
-              hanaStmt2.result += 1;
-              if (hanaStmt2.currentRow === hanaStmt2.paramsArray.length) {
-                hanaStmt2.callback(null, hanaStmt2.result);
-              } else {
-                hanaStmt2._exec();
-              }
-            }
-          }
-        });
-      });
-      this.params[paramIndex].on("data", function(buffer) {
-        hanaStmt2.params[paramIndex].pause();
-        hanaStmt2.stmt.sendParameterData(paramIndex, buffer, function(err2) {
-          if (err2) {
-            hanaStmt2.callback(err2);
-          } else {
-            hanaStmt2.params[paramIndex].resume();
-          }
-        });
-      });
-      this.params[paramIndex].resume();
-    };
-    function HanaProcStatement(connection, sql, callback) {
-      if (connection === void 0 || connection === null) {
-        handleError("Invalid parameter 'connection'.", callback);
-        return;
-      }
-      if (sql === void 0 || sql === null) {
-        handleError("Invalid parameter 'sql'.", callback);
-        return;
-      }
-      if (callback !== void 0 && callback !== null && typeof callback !== "function") {
-        throw new Error("Invalid parameter 'callback'.");
-      }
-      this.connection = connection;
-      this.columnInfo = [];
-      if (callback) {
-        var hanaStmt2 = this;
-        connection.prepare(sql, function(err2, stmt) {
-          hanaStmt2.stmt = stmt;
-          callback(err2, hanaStmt2);
-        });
-      } else {
-        this.stmt = connection.prepare(sql);
-        return this;
-      }
-    }
-    HanaProcStatement.prototype.drop = function(callback) {
-      if (this.stmt) {
-        var stmt = this.stmt;
-        this.stmt = null;
-        stmt.drop(callback);
-      }
-    };
-    HanaProcStatement.prototype.exec = function(...args2) {
-      if (args2.length != 2 && args2.length != 3) {
-        throw new Error("Invalid number of parameters - exec(params, [options,] callback).");
-      }
-      var params = args2[0];
-      if (args2.length == 2) {
-        var options = {};
-        var callback = args2[1];
-      } else if (args2.length == 3) {
-        var options = args2[1];
-        var callback = args2[2];
-      }
-      if (params !== void 0 && params !== null && (!(params instanceof Array) && !(params instanceof Object))) {
-        handleError("Invalid parameter 'params'.", callback);
-        return;
-      }
-      if (callback === void 0 || callback === null || typeof callback !== "function") {
-        throw new Error("Invalid parameter 'callback'.");
-      }
-      if (!this.stmt) {
-        handleError("Invalid statement.", callback);
-        return;
-      }
-      this.callback = callback;
-      this.scalarParams = {};
-      this.hasScalarParams = false;
-      this.tableParams = [[]];
-      this.currentTable = 0;
-      this.columnInfo = [];
-      var hanaStmt2 = this;
-      this.stmt.execQuery(params, options, function(err2, rs) {
-        if (err2) {
-          hanaStmt2.callback(err2);
-        } else {
-          hanaStmt2.rs = rs;
-          var paramInfo = hanaStmt2.stmt.getParameterInfo();
-          var paramCount = 0;
-          for (var i2 = 0; i2 < paramInfo.length; i2++) {
-            if (paramInfo[i2].direction === 2 || paramInfo[i2].direction === 3) {
-              hanaStmt2.hasScalarParams = true;
-              hanaStmt2.stmt.getParameterValue(i2, /* @__PURE__ */ (function() {
-                var index = i2;
-                return function(err3, val) {
-                  if (err3) {
-                    hanaStmt2.callback(err3);
-                  } else {
-                    ++paramCount;
-                    hanaStmt2.scalarParams[paramInfo[index].name] = val;
-                    if (paramCount === paramInfo.length) {
-                      return hanaStmt2.fetchTableParam();
-                    }
-                  }
-                };
-              })());
-            } else {
-              ++paramCount;
-            }
-          }
-          if (paramCount === paramInfo.length) {
-            hanaStmt2.fetchTableParam();
-          }
-        }
-      });
-    };
-    HanaProcStatement.prototype.getColumnInfo = function() {
-      return this.columnInfo;
-    };
-    HanaProcStatement.prototype.execute = function(params, callback) {
-      this.exec(params, callback);
-    };
-    HanaProcStatement.prototype.fetchTableParam = function() {
-      function fetchNextResult(hanaStmt) {
-        var columns = hanaStmt.rs.getColumnInfo();
-        if (columns != null && columns != void 0 && columns.length > 0) {
-          hanaStmt.columnInfo.push(columns);
-        }
-        hanaStmt.rs.nextResult(function(err, hasResult) {
-          if (err) {
-            hanaStmt.callback(err);
-          } else if (hasResult) {
-            hanaStmt.currentTable++;
-            hanaStmt.tableParams.push([]);
-            hanaStmt.fetchTableParam();
-          } else {
-            hanaStmt.rs.close(function(err) {
-              if (err) {
-                hanaStmt.callback(err);
-              } else {
-                var args = [];
-                if (hanaStmt.hasScalarParams) {
-                  args.push(hanaStmt.scalarParams);
-                } else {
-                  args.push({});
-                }
-                for (var i = 0; i < hanaStmt.tableParams.length; i++) {
-                  args.push(hanaStmt.tableParams[i]);
-                }
-                var evalStr = "hanaStmt.callback(null";
-                for (var j = 0; j < args.length; j++) {
-                  evalStr += ", args[" + j + "]";
-                }
-                evalStr += ")";
-                eval(evalStr);
-              }
-            });
-          }
-        });
-      }
-      var hanaStmt = this;
-      if (this.rs.nextCanBlock()) {
-        this.rs.next(function(err2, hasData) {
-          if (err2) {
-            hanaStmt.callback(err2);
-          } else {
-            if (hasData) {
-              try {
-                hanaStmt.tableParams[hanaStmt.currentTable].push(hanaStmt.rs.getValues());
-              } catch (newerr) {
-                hanaStmt.callback(newerr);
-                return;
-              }
-              hanaStmt.fetchTableParam();
-            } else {
-              fetchNextResult(hanaStmt);
-            }
-          }
-        });
-      } else {
-        var hasDataSync = false;
-        try {
-          hasDataSync = this.rs.next();
-          if (hasDataSync) {
-            hanaStmt.tableParams[hanaStmt.currentTable].push(hanaStmt.rs.getValues());
-          }
-        } catch (newerr) {
-          hanaStmt.callback(newerr);
-          return;
-        }
-        if (hasDataSync) {
-          hanaStmt.fetchTableParam();
-        } else {
-          fetchNextResult(hanaStmt);
-        }
-      }
-    };
-    function handleError(err2, callback) {
-      if (callback) {
-        callback(err2);
-      } else {
-        throw err2;
-      }
-    }
-    function isLob(type) {
-      if (type === 25 || // CLOB
-      type === 26 || // NCLOB
-      type === 27 || // BLOB
-      type === 13) {
-        return true;
-      }
-      return false;
-    }
-    function checkParameter(name, param) {
-      if (param === void 0 || param === null) {
-        throw new Error("Invalid parameter '" + name + "'.");
-      }
-    }
-    function checkColumnIndex(columnInfo, columnIndex) {
-      if (columnIndex === void 0 || columnIndex === null || columnIndex < 0 || columnIndex >= columnInfo.length) {
-        throw new Error("Invalid parameter 'columnIndex'.");
-      }
-    }
-    function checkLobType(columnInfo, columnIndex) {
-      var type = columnInfo[columnIndex].nativeType;
-      if (!isLob(type)) {
-        throw new Error("Column is not LOB type.");
-      }
-    }
-    function checkParameterIndex(paramInfo, paramIndex) {
-      if (paramIndex === void 0 || paramIndex === null || paramIndex < 0 || paramIndex >= paramInfo.length) {
-        throw new Error("Invalid parameter 'paramIndex'.");
-      }
-    }
-    function checkParameterLobType(paramInfo, paramIndex) {
-      var type = paramInfo[paramIndex].nativeType;
-      if (!isLob(type)) {
-        throw new Error("Parameter is not LOB type.");
-      }
-    }
-    function createBuffer(size) {
-      if (typeof Buffer.alloc === "function") {
-        return Buffer.alloc(size);
-      } else {
-        return new Buffer(size);
-      }
-    }
-    function isInteger(value) {
-      if (typeof value === "number" && value % 1 === 0) {
-        return true;
-      } else {
-        return false;
-      }
-    }
-    function getLobStreamOptions(options) {
-      var opts = {};
-      Object.assign(opts, options);
-      opts.objectMode = false;
-      if (isInteger(opts.readSize) && opts.readSize > 0) {
-        opts.highWaterMark = opts.readSize;
-      }
-      opts.noPause = false;
-      if (options && "noPause" in options && typeof options.noPause === "boolean") {
-        opts.noPause = options.noPause;
-      }
-      return opts;
-    }
-    var MAX_READ_SIZE = Math.pow(2, 18);
-    var DEFAULT_READ_SIZE = Math.pow(2, 11) * 100;
-  }
-});
-
-export {
-  require_Stream
-};
-//# sourceMappingURL=chunk-I3F3SOHM.js.map