@housekit/orm 0.1.43 → 0.1.44

package/dist/builders/select.d.ts

@@ -254,25 +254,20 @@ export declare class ClickHouseQueryBuilder<TTable extends TableDefinition<any>
     stream(): AsyncIterableIterator<TResult>;
     /**
      * Native binary mode for high-performance data retrieval.
-     * Reads data using ClickHouse 'RowBinary' format and parses it directly in Node.js.
-     * Up to 10x faster than standard JSON select for large datasets.
      *
-     * Requirements: All selected columns must be strictly typed (ClickHouseColumn instances).
+     * @deprecated RowBinary streaming is not supported by @clickhouse/client 1.15+.
+     * Use standard select() which uses optimized JSONEachRow format.
      */
     native(): Promise<TResult[]>;
     /**
      * Vector mode for columnar data retrieval.
-     * Returns data in Columnar format (TypedArrays) instead of Row-based objects.
-     * Ideal for analytical processing, charting, or passing to libraries like Apache Arrow.
      *
-     * @example
-     * const { prices } = await db.select({ prices: trades.price }).vector();
-     * // prices is a Float64Array
+     * @deprecated RowBinary streaming is not supported by @clickhouse/client 1.15+.
+     * Use standard select() which uses optimized JSONEachRow format.
      */
     vector(): Promise<{
         [K in keyof TResult]: TResult[K] extends number ? (TResult[K] extends number ? Float64Array | Int32Array : Array<TResult[K]>) : Array<TResult[K]>;
     }>;
-    private executeBinary;
     explain(): Promise<any>;
     explainPipeline(): Promise<any>;
     /**

package/dist/index.js

@@ -15,379 +15,8 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/utils/binary-reader.ts
-var exports_binary_reader = {};
-__export(exports_binary_reader, {
-  createBinaryDecoder: () => createBinaryDecoder,
-  BinaryReader: () => BinaryReader
-});
-
-class BinaryReader {
-  buffer;
-  offset = 0;
-  view;
-  constructor(buffer) {
-    this.buffer = buffer;
-    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-  }
-  reset(buffer) {
-    this.buffer = buffer;
-    this.offset = 0;
-    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-  }
-  getOffset() {
-    return this.offset;
-  }
-  isEOF() {
-    return this.offset >= this.buffer.length;
-  }
-  readInt8() {
-    const val = this.view.getInt8(this.offset);
-    this.offset += 1;
-    return val;
-  }
-  readUInt8() {
-    const val = this.view.getUint8(this.offset);
-    this.offset += 1;
-    return val;
-  }
-  readInt16() {
-    const val = this.view.getInt16(this.offset, true);
-    this.offset += 2;
-    return val;
-  }
-  readUInt16() {
-    const val = this.view.getUint16(this.offset, true);
-    this.offset += 2;
-    return val;
-  }
-  readInt32() {
-    const val = this.view.getInt32(this.offset, true);
-    this.offset += 4;
-    return val;
-  }
-  readUInt32() {
-    const val = this.view.getUint32(this.offset, true);
-    this.offset += 4;
-    return val;
-  }
-  readInt64() {
-    const val = this.view.getBigInt64(this.offset, true);
-    this.offset += 8;
-    return val;
-  }
-  readUInt64() {
-    const val = this.view.getBigUint64(this.offset, true);
-    this.offset += 8;
-    return val;
-  }
-  readInt128() {
-    const low = this.view.getBigUint64(this.offset, true);
-    const high = this.view.getBigInt64(this.offset + 8, true);
-    this.offset += 16;
-    return high << 64n | low;
-  }
-  readUInt128() {
-    const low = this.view.getBigUint64(this.offset, true);
-    const high = this.view.getBigUint64(this.offset + 8, true);
-    this.offset += 16;
-    return high << 64n | low;
-  }
-  readInt256() {
-    let val = 0n;
-    for (let i = 0;i < 4; i++) {
-      const word = this.view.getBigUint64(this.offset + i * 8, true);
-      val |= word << BigInt(i) * 64n;
-    }
-    this.offset += 32;
-    return val;
-  }
-  readUInt256() {
-    return this.readInt256();
-  }
-  readFloat32() {
-    const val = this.view.getFloat32(this.offset, true);
-    this.offset += 4;
-    return val;
-  }
-  readFloat64() {
-    const val = this.view.getFloat64(this.offset, true);
-    this.offset += 8;
-    return val;
-  }
-  readVarInt() {
-    let result = 0;
-    let shift = 0;
-    while (true) {
-      const byte = this.buffer[this.offset++];
-      result |= (byte & 127) << shift;
-      if ((byte & 128) === 0)
-        break;
-      shift += 7;
-    }
-    return result;
-  }
-  readString() {
-    const len = this.readVarInt();
-    if (len === 0)
-      return "";
-    const str = this.buffer.toString("utf-8", this.offset, this.offset + len);
-    this.offset += len;
-    return str;
-  }
-  readFixedString(length) {
-    const str = this.buffer.toString("utf-8", this.offset, this.offset + length);
-    this.offset += length;
-    return str.replace(/\u0000+$/, "");
-  }
-  readUUID() {
-    const bytes = this.buffer.subarray(this.offset, this.offset + 16);
-    this.offset += 16;
-    const hex = Buffer.allocUnsafe(16);
-    for (let i = 0;i < 8; i++) {
-      hex[i] = bytes[7 - i];
-    }
-    for (let i = 0;i < 8; i++) {
-      hex[8 + i] = bytes[15 - i];
-    }
-    const s = hex.toString("hex");
-    return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
-  }
-  readDate() {
-    const days = this.readUInt16();
-    const date = new Date(days * 24 * 60 * 60 * 1000);
-    return date.toISOString().split("T")[0];
-  }
-  readDate32() {
-    const days = this.readInt32();
-    const date = new Date(days * 24 * 60 * 60 * 1000);
-    return date.toISOString().split("T")[0];
-  }
-  readDateTime() {
-    const seconds = this.readUInt32();
-    return new Date(seconds * 1000);
-  }
-  readDateTime64(precision = 3) {
-    const ticks = this.readInt64();
-    const divisor = BigInt(Math.pow(10, precision));
-    let ms;
-    if (precision === 3) {
-      ms = ticks;
-    } else if (precision > 3) {
-      ms = ticks / BigInt(Math.pow(10, precision - 3));
-    } else {
-      ms = ticks * BigInt(Math.pow(10, 3 - precision));
-    }
-    return new Date(Number(ms));
-  }
-  readNullable(reader) {
-    const isNull2 = this.readUInt8();
-    if (isNull2 === 1)
-      return null;
-    return reader();
-  }
-  readArray(itemReader) {
-    const lenBig = this.readUInt64();
-    const length = Number(lenBig);
-    const res = new Array(length);
-    for (let i = 0;i < length; i++) {
-      res[i] = itemReader();
-    }
-    return res;
-  }
-  readMap(keyReader, valueReader) {
-    const lenBig = this.readUInt64();
-    const length = Number(lenBig);
-    const res = {};
-    for (let i = 0;i < length; i++) {
-      const key = keyReader();
-      const value = valueReader();
-      res[key] = value;
-    }
-    return res;
-  }
-  readDecimal32(scale) {
-    const val = this.readInt32();
-    return val / Math.pow(10, scale);
-  }
-  readDecimal64(scale) {
-    const val = this.readInt64();
-    return Number(val) / Math.pow(10, scale);
-  }
-  readDecimal128(scale) {
-    const val = this.readInt128();
-    return Number(val) / Math.pow(10, scale);
-  }
-  readBool() {
-    return this.readUInt8() === 1;
-  }
-  readIPv4() {
-    const val = this.readUInt32();
-    return [
-      val & 255,
-      val >> 8 & 255,
-      val >> 16 & 255,
-      val >> 24 & 255
-    ].join(".");
-  }
-  readIPv6() {
-    const buffer = this.buffer.subarray(this.offset, this.offset + 16);
-    this.offset += 16;
-    const parts = [];
-    for (let i = 0;i < 16; i += 2) {
-      const group = buffer.readUInt16BE(i).toString(16);
-      parts.push(group);
-    }
-    return parts.join(":").replace(/(^|:)0(:0)*:0(:|$)/, "::");
-  }
-}
-function createBinaryDecoder(type) {
-  const t = type.toLowerCase().trim();
-  if (t.startsWith("nullable(")) {
-    const inner = t.match(/^nullable\((.+)\)$/)[1];
-    const innerDecoder = createBinaryDecoder(inner);
-    return (r) => r.readNullable(() => innerDecoder(r));
-  }
-  if (t.startsWith("array(")) {
-    const inner = t.match(/^array\((.+)\)$/)[1];
-    const innerDecoder = createBinaryDecoder(inner);
-    return (r) => r.readArray(() => innerDecoder(r));
-  }
-  if (t.startsWith("map(")) {
-    const inner = t.match(/^map\((.+)\)$/)[1];
-    const [keyType, valueType] = parseGenericTypes(inner);
-    const keyDecoder = createBinaryDecoder(keyType);
-    const valueDecoder = createBinaryDecoder(valueType);
-    return (r) => r.readMap(() => keyDecoder(r), () => valueDecoder(r));
-  }
-  if (t.startsWith("tuple(")) {
-    const inner = t.match(/^tuple\((.+)\)$/)[1];
-    const types = parseGenericTypes(inner);
-    const decoders = types.map((type2) => createBinaryDecoder(type2));
-    return (r) => decoders.map((d) => d(r));
-  }
-  if (t.startsWith("nested(")) {
-    const inner = t.match(/^nested\((.+)\)$/)[1];
-    const fields = parseGenericTypes(inner);
-    const types = fields.map((f) => {
-      const parts = f.trim().split(/\s+/);
-      return parts.length < 2 ? "String" : parts.slice(1).join(" ");
-    });
-    const tupleDecoders = types.map((type2) => createBinaryDecoder(type2));
-    return (r) => r.readArray(() => tupleDecoders.map((d) => d(r)));
-  }
-  if (t.startsWith("lowcardinality(")) {
-    const inner = t.match(/^lowcardinality\((.+)\)$/)[1];
-    return createBinaryDecoder(inner);
-  }
-  if (t.startsWith("fixedstring(")) {
-    const len = parseInt(t.match(/\d+/)[0], 10);
-    return (r) => r.readFixedString(len);
-  }
-  if (t.startsWith("decimal")) {
-    const match = t.match(/^decimal(?:32|64|128)?\((\d+),\s*(\d+)\)$/);
-    if (match) {
-      const scale = parseInt(match[2], 10);
-      if (t.includes("decimal128"))
-        return (r) => r.readDecimal128(scale);
-      if (t.includes("decimal64"))
-        return (r) => r.readDecimal64(scale);
-      return (r) => r.readDecimal32(scale);
-    }
-  }
-  if (t.startsWith("datetime64")) {
-    const match = t.match(/^datetime64\((\d+)/);
-    const precision = match ? parseInt(match[1], 10) : 3;
-    return (r) => r.readDateTime64(precision);
-  }
-  if (t.startsWith("enum")) {
-    if (t.startsWith("enum8"))
-      return (r) => r.readInt8();
-    return (r) => r.readInt16();
-  }
-  switch (t) {
-    case "uint8":
-      return (r) => r.readUInt8();
-    case "int8":
-      return (r) => r.readInt8();
-    case "uint16":
-      return (r) => r.readUInt16();
-    case "int16":
-      return (r) => r.readInt16();
-    case "uint32":
-      return (r) => r.readUInt32();
-    case "int32":
-      return (r) => r.readInt32();
-    case "uint64":
-      return (r) => r.readUInt64();
-    case "int64":
-      return (r) => r.readInt64();
-    case "uint128":
-      return (r) => r.readUInt128();
-    case "int128":
-      return (r) => r.readInt128();
-    case "uint256":
-      return (r) => r.readUInt256();
-    case "int256":
-      return (r) => r.readInt256();
-    case "float32":
-      return (r) => r.readFloat32();
-    case "float64":
-      return (r) => r.readFloat64();
-    case "string":
-      return (r) => r.readString();
-    case "uuid":
-      return (r) => r.readUUID();
-    case "bool":
-      return (r) => r.readBool();
-    case "date":
-      return (r) => r.readDate();
-    case "date32":
-      return (r) => r.readDate32();
-    case "datetime":
-      return (r) => r.readDateTime();
-    case "ipv4":
-      return (r) => r.readIPv4();
-    case "ipv6":
-      return (r) => r.readIPv6();
-    default:
-      return (r) => r.readString();
-  }
-}
-function parseGenericTypes(typeString) {
-  const args = [];
-  let current = "";
-  let parenDepth = 0;
-  for (let i = 0;i < typeString.length; i++) {
-    const char = typeString[i];
-    if (char === "," && parenDepth === 0) {
-      args.push(current.trim());
-      current = "";
-    } else {
-      if (char === "(")
-        parenDepth++;
-      if (char === ")")
-        parenDepth--;
-      current += char;
-    }
-  }
-  if (current.trim()) {
-    args.push(current.trim());
-  }
-  return args;
-}
-
 // src/index.ts
 import { resolve, join } from "path";
 import { existsSync, readdirSync } from "fs";
@@ -2361,34 +1990,6 @@ class PreparedQuery {
         query_params[this.paramKeys[i]] = values2[i];
       }
     }
-    const limitMatch = this.sql.match(/LIMIT\s+(\d+)/i);
-    const limit = limitMatch ? parseInt(limitMatch[1], 10) : Infinity;
-    const useBinary = limit >= 1e5 && this.columnTypes.length > 0;
-    if (useBinary) {
-      const resultSet2 = await this.client.query({
-        query: this.sql,
-        query_params,
-        format: "RowBinary"
-      });
-      const { BinaryReader: BinaryReader2, createBinaryDecoder: createBinaryDecoder2 } = await Promise.resolve().then(() => exports_binary_reader);
-      const response = await resultSet2.stream();
-      const decoder = this.columnTypes.map((type) => createBinaryDecoder2(type));
-      const results = [];
-      const chunks = [];
-      for await (const chunk of response) {
-        chunks.push(chunk);
-      }
-      const fullBuffer = Buffer.concat(chunks);
-      const reader = new BinaryReader2(fullBuffer);
-      while (!reader.isEOF()) {
-        const row = {};
-        for (let i = 0;i < this.columnNames.length; i++) {
-          row[this.columnNames[i]] = decoder[i](reader);
-        }
-        results.push(row);
-      }
-      return results;
-    }
     const resultSet = await this.client.query({
       query: this.sql,
       query_params,
@@ -3285,104 +2886,20 @@ class ClickHouseQueryBuilder {
     return this[Symbol.asyncIterator]();
   }
   async native() {
-    return this.executeBinary("object");
+    console.warn("[HouseKit] native() is deprecated. RowBinary streaming is not supported by @clickhouse/client 1.15+. Using JSONEachRow instead.");
+    return this.then((data) => data);
   }
   async vector() {
-    return this.executeBinary("vector");
-  }
-  async executeBinary(mode) {
-    const compiler = new QueryCompiler;
-    const state = this.getState();
-    const columns = [];
-    if (state.select) {
-      for (const [key, val] of Object.entries(state.select)) {
-        if (val instanceof ClickHouseColumn) {
-          columns.push({ name: key, type: val.type, decoder: createBinaryDecoder(val.type) });
-        } else if (val && typeof val === "object" && "_type" in val && val.type) {
-          throw new Error(`[HouseKit] Binary mode requires strictly typed columns. Field '${key}' is an expression without type info.`);
-        } else {
-          throw new Error(`[HouseKit] Binary mode requires strictly typed columns. Field '${key}' is not a ClickHouseColumn.`);
-        }
-      }
-    } else if (state.table) {
-      const tableCols = state.table.$columns;
-      for (const [key, col] of Object.entries(tableCols)) {
-        columns.push({ name: key, type: col.type, decoder: createBinaryDecoder(col.type) });
-      }
-    } else {
-      throw new Error("[HouseKit] Binary mode requires a table or explicit selection.");
-    }
-    const { cachedQuery, values: values2 } = compiler.compileWithCache(state, this.client);
-    const query_params = {};
-    for (let i = 0;i < values2.length; i++) {
-      query_params[`p_${i + 1}`] = values2[i];
-    }
-    const resultSet = await this.client.query({
-      query: cachedQuery.sql,
-      query_params,
-      format: "RowBinary"
-    });
-    const chunks = [];
-    const stream = resultSet.stream();
-    for await (const chunk of stream) {
-      chunks.push(chunk);
-    }
-    const fullBuffer = Buffer.concat(chunks);
-    const reader = new BinaryReader(fullBuffer);
-    const count = fullBuffer.length;
-    if (mode === "object") {
-      const rows = [];
-      while (!reader.isEOF()) {
-        const row = {};
-        for (const col of columns) {
-          row[col.name] = col.decoder(reader);
-        }
-        rows.push(row);
-      }
-      return rows;
-    } else {
-      const data = {};
-      for (const col of columns) {
-        data[col.name] = [];
-      }
-      while (!reader.isEOF()) {
-        for (const col of columns) {
-          data[col.name].push(col.decoder(reader));
-        }
-      }
-      const finalVectors = {};
-      for (const col of columns) {
-        const arr = data[col.name];
-        const type = col.type.toLowerCase();
-        if (type.includes("int") || type.includes("float")) {
-          if (type === "int8")
-            finalVectors[col.name] = new Int8Array(arr);
-          else if (type === "uint8")
-            finalVectors[col.name] = new Uint8Array(arr);
-          else if (type === "int16")
-            finalVectors[col.name] = new Int16Array(arr);
-          else if (type === "uint16")
-            finalVectors[col.name] = new Uint16Array(arr);
-          else if (type === "int32")
-            finalVectors[col.name] = new Int32Array(arr);
-          else if (type === "uint32")
-            finalVectors[col.name] = new Uint32Array(arr);
-          else if (type === "int64")
-            finalVectors[col.name] = new BigInt64Array(arr);
-          else if (type === "uint64")
-            finalVectors[col.name] = new BigUint64Array(arr);
-          else if (type === "float32")
-            finalVectors[col.name] = new Float32Array(arr);
-          else if (type === "float64")
-            finalVectors[col.name] = new Float64Array(arr);
-          else
-            finalVectors[col.name] = arr;
-        } else {
-          finalVectors[col.name] = arr;
-        }
-      }
-      return finalVectors;
+    console.warn("[HouseKit] vector() is deprecated. RowBinary streaming is not supported by @clickhouse/client 1.15+. Using JSONEachRow instead.");
+    const rows = await this.then((data) => data);
+    if (rows.length === 0)
+      return {};
+    const result = {};
+    const keys = Object.keys(rows[0]);
+    for (const key of keys) {
+      result[key] = rows.map((row) => row[key]);
     }
+    return result;
   }
   async explain() {
     const { query, params } = this.toSQL();
@@ -4022,7 +3539,7 @@ class BinaryWriter {
     this.writeInt16(value);
   }
 }
-function parseGenericTypes2(typeString) {
+function parseGenericTypes(typeString) {
   const args = [];
   let current = "";
   let parenDepth = 0;
@@ -4071,7 +3588,7 @@ function createBinaryEncoder(clickhouseType, isNullable = false) {
   }
   const mapMatch = type.match(/^map\((.+)\)$/);
   if (mapMatch) {
-    const [keyType, valueType] = parseGenericTypes2(mapMatch[1]);
+    const [keyType, valueType] = parseGenericTypes(mapMatch[1]);
     if (!keyType || !valueType)
       throw new Error(`Invalid Map type: ${type}`);
     const keyEncoder = createBinaryEncoder(keyType);
@@ -4094,7 +3611,7 @@ function createBinaryEncoder(clickhouseType, isNullable = false) {
   }
   const tupleMatch = type.match(/^tuple\((.+)\)$/);
   if (tupleMatch) {
-    const types = parseGenericTypes2(tupleMatch[1]);
+    const types = parseGenericTypes(tupleMatch[1]);
     const encoders = types.map((t) => createBinaryEncoder(t));
     return (writer, value) => {
       const arr = Array.isArray(value) ? value : [];
@@ -4105,7 +3622,7 @@ function createBinaryEncoder(clickhouseType, isNullable = false) {
   }
   const nestedMatch = type.match(/^nested\((.+)\)$/);
   if (nestedMatch) {
-    const fields = parseGenericTypes2(nestedMatch[1]);
+    const fields = parseGenericTypes(nestedMatch[1]);
     const types = fields.map((f) => {
       const parts = f.trim().split(/\s+/);
       if (parts.length < 2)

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@housekit/orm",
-    "version": "0.1.43",
+    "version": "0.1.44",
     "description": "Type-safe ClickHouse ORM with modern DX and ClickHouse-specific optimizations. Features optimized JSONCompact streaming, full engine support, and advanced query capabilities.",
     "type": "module",
     "main": "./dist/index.js",