@housekit/orm 0.1.47 → 0.1.49

package/dist/utils/binary-serializer.js

@@ -0,0 +1,637 @@
+const hasNativeUUID = typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function';
+let uuidv4Fn = null;
+function generateUUIDv4() {
+    if (hasNativeUUID)
+        return crypto.randomUUID();
+    if (uuidv4Fn)
+        return uuidv4Fn();
+    const uuid = require('uuid');
+    uuidv4Fn = uuid.v4;
+    return uuidv4Fn();
+}
+const WRITER_POOL_SIZE = 8;
+const writerPool = [];
+let poolInitialized = false;
+function initWriterPool() {
+    if (poolInitialized)
+        return;
+    for (let i = 0; i < WRITER_POOL_SIZE; i++) {
+        writerPool.push(new BinaryWriter(64 * 1024));
+    }
+    poolInitialized = true;
+}
+export function acquireWriter() {
+    initWriterPool();
+    const writer = writerPool.pop();
+    if (writer) {
+        writer.reset();
+        return writer;
+    }
+    return new BinaryWriter(64 * 1024);
+}
+export function releaseWriter(writer) {
+    if (writerPool.length < WRITER_POOL_SIZE) {
+        writer.reset();
+        writerPool.push(writer);
+    }
+}
+export class BinaryWriter {
+    buffer;
+    offset = 0;
+    constructor(initialSize = 4096) {
+        this.buffer = Buffer.allocUnsafe(initialSize);
+    }
+    ensureCapacity(bytes) {
+        const required = this.offset + bytes;
+        if (required > this.buffer.length) {
+            const newSize = Math.max(this.buffer.length * 2, required);
+            const newBuffer = Buffer.allocUnsafe(newSize);
+            this.buffer.copy(newBuffer, 0, 0, this.offset);
+            this.buffer = newBuffer;
+        }
+    }
+    reset() {
+        this.offset = 0;
+    }
+    getBuffer() {
+        return this.buffer.subarray(0, this.offset);
+    }
+    toBuffer() {
+        return Buffer.from(this.buffer.subarray(0, this.offset));
+    }
+    writeInt8(value) {
+        this.ensureCapacity(1);
+        this.buffer.writeInt8(value, this.offset);
+        this.offset += 1;
+    }
+    writeUInt8(value) {
+        this.ensureCapacity(1);
+        this.buffer.writeUInt8(value, this.offset);
+        this.offset += 1;
+    }
+    writeInt16(value) {
+        this.ensureCapacity(2);
+        this.buffer.writeInt16LE(value, this.offset);
+        this.offset += 2;
+    }
+    writeUInt16(value) {
+        this.ensureCapacity(2);
+        this.buffer.writeUInt16LE(value, this.offset);
+        this.offset += 2;
+    }
+    writeInt32(value) {
+        this.ensureCapacity(4);
+        this.buffer.writeInt32LE(value, this.offset);
+        this.offset += 4;
+    }
+    writeUInt32(value) {
+        this.ensureCapacity(4);
+        this.buffer.writeUInt32LE(value, this.offset);
+        this.offset += 4;
+    }
+    writeInt64(value) {
+        this.ensureCapacity(8);
+        this.buffer.writeBigInt64LE(BigInt(value), this.offset);
+        this.offset += 8;
+    }
+    writeUInt64(value) {
+        this.ensureCapacity(8);
+        this.buffer.writeBigUInt64LE(BigInt(value), this.offset);
+        this.offset += 8;
+    }
+    writeInt128(value) {
+        this.ensureCapacity(16);
+        const low = value & BigInt('0xFFFFFFFFFFFFFFFF');
+        const high = value >> BigInt(64);
+        this.buffer.writeBigUInt64LE(low, this.offset);
+        this.buffer.writeBigInt64LE(high, this.offset + 8);
+        this.offset += 16;
+    }
+    writeUInt128(value) {
+        this.ensureCapacity(16);
+        const low = value & BigInt('0xFFFFFFFFFFFFFFFF');
+        const high = value >> BigInt(64);
+        this.buffer.writeBigUInt64LE(low, this.offset);
+        this.buffer.writeBigUInt64LE(high, this.offset + 8);
+        this.offset += 16;
+    }
+    writeInt256(value) {
+        this.ensureCapacity(32);
+        for (let i = 0; i < 4; i++) {
+            const word = value & BigInt('0xFFFFFFFFFFFFFFFF');
+            this.buffer.writeBigUInt64LE(word, this.offset + i * 8);
+            value >>= BigInt(64);
+        }
+        this.offset += 32;
+    }
+    writeUInt256(value) {
+        this.writeInt256(value);
+    }
+    writeFloat32(value) {
+        this.ensureCapacity(4);
+        this.buffer.writeFloatLE(value, this.offset);
+        this.offset += 4;
+    }
+    writeFloat64(value) {
+        this.ensureCapacity(8);
+        this.buffer.writeDoubleLE(value, this.offset);
+        this.offset += 8;
+    }
+    writeVarInt(value) {
+        if (value < 0x80) {
+            this.ensureCapacity(1);
+            this.buffer[this.offset++] = value;
+            return;
+        }
+        if (value < 0x4000) {
+            this.ensureCapacity(2);
+            this.buffer[this.offset++] = (value & 0x7f) | 0x80;
+            this.buffer[this.offset++] = value >> 7;
+            return;
+        }
+        if (value < 0x200000) {
+            this.ensureCapacity(3);
+            this.buffer[this.offset++] = (value & 0x7f) | 0x80;
+            this.buffer[this.offset++] = ((value >> 7) & 0x7f) | 0x80;
+            this.buffer[this.offset++] = value >> 14;
+            return;
+        }
+        this.ensureCapacity(10);
+        while (value >= 0x80) {
+            this.buffer[this.offset++] = (value & 0x7f) | 0x80;
+            value >>>= 7;
+        }
+        this.buffer[this.offset++] = value;
+    }
+    writeString(value) {
+        const strBuffer = Buffer.from(value, 'utf-8');
+        this.writeVarInt(strBuffer.length);
+        this.ensureCapacity(strBuffer.length);
+        strBuffer.copy(this.buffer, this.offset);
+        this.offset += strBuffer.length;
+    }
+    writeFixedString(value, length) {
+        this.ensureCapacity(length);
+        const strBuffer = Buffer.from(value, 'utf-8');
+        const copyLen = Math.min(strBuffer.length, length);
+        strBuffer.copy(this.buffer, this.offset, 0, copyLen);
+        if (copyLen < length) {
+            this.buffer.fill(0, this.offset + copyLen, this.offset + length);
+        }
+        this.offset += length;
+    }
+    writeBytes(data) {
+        this.ensureCapacity(data.length);
+        data.copy(this.buffer, this.offset);
+        this.offset += data.length;
+    }
+    writeUUID(value) {
+        this.ensureCapacity(16);
+        const hex = value.replace(/-/g, '');
+        if (hex.length !== 32) {
+            throw new Error(`Invalid UUID: ${value}`);
+        }
+        const bytes = Buffer.from(hex, 'hex');
+        for (let i = 7; i >= 0; i--) {
+            this.buffer[this.offset++] = bytes[i];
+        }
+        for (let i = 15; i >= 8; i--) {
+            this.buffer[this.offset++] = bytes[i];
+        }
+    }
+    writeDate(value) {
+        const days = typeof value === 'number'
+            ? value
+            : Math.floor(value.getTime() / (1000 * 60 * 60 * 24));
+        this.writeUInt16(days);
+    }
+    writeDate32(value) {
+        const days = typeof value === 'number'
+            ? value
+            : Math.floor(value.getTime() / (1000 * 60 * 60 * 24));
+        this.writeInt32(days);
+    }
+    writeDateTime(value) {
+        const seconds = typeof value === 'number'
+            ? value
+            : Math.floor(value.getTime() / 1000);
+        this.writeUInt32(seconds);
+    }
+    writeDateTime64(value, precision = 3) {
+        const multiplier = Math.pow(10, precision);
+        const ticks = typeof value === 'number'
+            ? BigInt(Math.round(value * multiplier))
+            : BigInt(Math.round(value.getTime() * multiplier / 1000));
+        this.writeInt64(ticks);
+    }
+    writeNullable(isNull) {
+        this.writeUInt8(isNull ? 1 : 0);
+    }
+    writeArrayLength(length) {
+        this.writeUInt64(length);
+    }
+    writeDecimal32(value, scale) {
+        const scaled = Math.round(value * Math.pow(10, scale));
+        this.writeInt32(scaled);
+    }
+    writeDecimal64(value, scale) {
+        const scaled = BigInt(Math.round(value * Math.pow(10, scale)));
+        this.writeInt64(scaled);
+    }
+    writeDecimal128(value, scale) {
+        let scaled;
+        if (typeof value === 'bigint') {
+            scaled = value * BigInt(Math.pow(10, scale));
+        }
+        else {
+            scaled = BigInt(Math.round(value * Math.pow(10, scale)));
+        }
+        this.writeInt128(scaled);
+    }
+    writeBool(value) {
+        this.writeUInt8(value ? 1 : 0);
+    }
+    writeIPv4(value) {
+        if (typeof value === 'number') {
+            this.writeUInt32(value);
+            return;
+        }
+        const parts = value.split('.').map(Number);
+        if (parts.length !== 4) {
+            throw new Error(`Invalid IPv4: ${value}`);
+        }
+        const num = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3];
+        this.writeUInt32(num >>> 0);
+    }
+    writeIPv6(value) {
+        if (Buffer.isBuffer(value)) {
+            if (value.length !== 16) {
+                throw new Error('IPv6 must be 16 bytes');
+            }
+            this.writeBytes(value);
+            return;
+        }
+        const expanded = this.expandIPv6(value);
+        const parts = expanded.split(':');
+        this.ensureCapacity(16);
+        for (const part of parts) {
+            const num = parseInt(part, 16);
+            this.buffer.writeUInt16BE(num, this.offset);
+            this.offset += 2;
+        }
+    }
+    expandIPv6(ip) {
+        const parts = ip.split('::');
+        if (parts.length === 1) {
+            return ip;
+        }
+        const left = parts[0] ? parts[0].split(':') : [];
+        const right = parts[1] ? parts[1].split(':') : [];
+        const missing = 8 - left.length - right.length;
+        const middle = Array(missing).fill('0000');
+        return [...left, ...middle, ...right].map(p => p.padStart(4, '0')).join(':');
+    }
+    writeEnum8(value) {
+        this.writeInt8(value);
+    }
+    writeEnum16(value) {
+        this.writeInt16(value);
+    }
+}
+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;
+}
+export function createBinaryEncoder(clickhouseType, isNullable = false) {
+    const type = clickhouseType.toLowerCase().trim();
+    const nullableMatch = type.match(/^nullable\((.+)\)$/);
+    if (nullableMatch) {
+        const innerEncoder = createBinaryEncoder(nullableMatch[1], false);
+        return (writer, value) => {
+            if (value === null || value === undefined) {
+                writer.writeNullable(true);
+            }
+            else {
+                writer.writeNullable(false);
+                innerEncoder(writer, value);
+            }
+        };
+    }
+    const arrayMatch = type.match(/^array\((.+)\)$/);
+    if (arrayMatch) {
+        const elementEncoder = createBinaryEncoder(arrayMatch[1], false);
+        return (writer, value) => {
+            const arr = Array.isArray(value) ? value : [];
+            writer.writeArrayLength(arr.length);
+            for (const item of arr) {
+                elementEncoder(writer, item);
+            }
+        };
+    }
+    const mapMatch = type.match(/^map\((.+)\)$/);
+    if (mapMatch) {
+        const [keyType, valueType] = parseGenericTypes(mapMatch[1]);
+        if (!keyType || !valueType)
+            throw new Error(`Invalid Map type: ${type}`);
+        const keyEncoder = createBinaryEncoder(keyType);
+        const valueEncoder = createBinaryEncoder(valueType);
+        return (writer, value) => {
+            let entries;
+            if (value instanceof Map) {
+                entries = Array.from(value.entries());
+            }
+            else if (typeof value === 'object' && value !== null) {
+                entries = Object.entries(value);
+            }
+            else {
+                entries = [];
+            }
+            writer.writeUInt64(entries.length);
+            for (const [k, v] of entries) {
+                keyEncoder(writer, k);
+                valueEncoder(writer, v);
+            }
+        };
+    }
+    const tupleMatch = type.match(/^tuple\((.+)\)$/);
+    if (tupleMatch) {
+        const types = parseGenericTypes(tupleMatch[1]);
+        const encoders = types.map(t => createBinaryEncoder(t));
+        return (writer, value) => {
+            const arr = Array.isArray(value) ? value : [];
+            for (let i = 0; i < encoders.length; i++) {
+                encoders[i](writer, arr[i]);
+            }
+        };
+    }
+    const nestedMatch = type.match(/^nested\((.+)\)$/);
+    if (nestedMatch) {
+        const fields = parseGenericTypes(nestedMatch[1]);
+        const types = fields.map(f => {
+            const parts = f.trim().split(/\s+/);
+            if (parts.length < 2)
+                return 'String';
+            return parts.slice(1).join(' ');
+        });
+        const tupleType = `Tuple(${types.join(', ')})`;
+        const tupleEncoder = createBinaryEncoder(tupleType);
+        return (writer, value) => {
+            const arr = Array.isArray(value) ? value : [];
+            writer.writeArrayLength(arr.length);
+            for (const item of arr) {
+                let tupleValue = item;
+                if (!Array.isArray(item) && typeof item === 'object') {
+                    tupleValue = fields.map(f => {
+                        const name = f.trim().split(/\s+/)[0];
+                        return item[name];
+                    });
+                }
+                tupleEncoder(writer, tupleValue);
+            }
+        };
+    }
+    const lcMatch = type.match(/^lowcardinality\((.+)\)$/);
+    if (lcMatch) {
+        return createBinaryEncoder(lcMatch[1]);
+    }
+    const fixedStringMatch = type.match(/^fixedstring\((\d+)\)$/);
+    if (fixedStringMatch) {
+        const length = parseInt(fixedStringMatch[1], 10);
+        return (writer, value) => {
+            writer.writeFixedString(String(value ?? ''), length);
+        };
+    }
+    const decimalMatch = type.match(/^decimal(?:32|64|128)?\((\d+),\s*(\d+)\)$/);
+    if (decimalMatch) {
+        const scale = parseInt(decimalMatch[2], 10);
+        if (type.includes('decimal128')) {
+            return (writer, value) => writer.writeDecimal128(value, scale);
+        }
+        if (type.includes('decimal64')) {
+            return (writer, value) => writer.writeDecimal64(value, scale);
+        }
+        return (writer, value) => writer.writeDecimal32(value, scale);
+    }
+    const dt64Match = type.match(/^datetime64\((\d+)/);
+    if (dt64Match) {
+        const precision = parseInt(dt64Match[1], 10);
+        return (writer, value) => writer.writeDateTime64(value, precision);
+    }
+    const enum8Match = type.match(/^enum8\(/);
+    if (enum8Match) {
+        return (writer, value) => writer.writeEnum8(Number(value));
+    }
+    const enum16Match = type.match(/^enum16\(/);
+    if (enum16Match) {
+        return (writer, value) => writer.writeEnum16(Number(value));
+    }
+    const baseEncoder = getBaseTypeEncoder(type);
+    if (isNullable) {
+        return (writer, value) => {
+            if (value === null || value === undefined) {
+                writer.writeNullable(true);
+            }
+            else {
+                writer.writeNullable(false);
+                baseEncoder(writer, value);
+            }
+        };
+    }
+    if (type === 'uuid') {
+        return (writer, value) => {
+            if (value === undefined || value === null) {
+                baseEncoder(writer, generateUUIDv4());
+            }
+            else {
+                baseEncoder(writer, value);
+            }
+        };
+    }
+    return baseEncoder;
+}
+function getBaseTypeEncoder(type) {
+    if (type === 'int8')
+        return (w, v) => w.writeInt8(Number(v));
+    if (type === 'uint8')
+        return (w, v) => w.writeUInt8(Number(v));
+    if (type === 'int16')
+        return (w, v) => w.writeInt16(Number(v));
+    if (type === 'uint16')
+        return (w, v) => w.writeUInt16(Number(v));
+    if (type === 'int32')
+        return (w, v) => w.writeInt32(Number(v));
+    if (type === 'uint32')
+        return (w, v) => w.writeUInt32(Number(v));
+    if (type === 'int64')
+        return (w, v) => w.writeInt64(v);
+    if (type === 'uint64')
+        return (w, v) => w.writeUInt64(v);
+    if (type === 'int128')
+        return (w, v) => w.writeInt128(BigInt(v));
+    if (type === 'uint128')
+        return (w, v) => w.writeUInt128(BigInt(v));
+    if (type === 'int256')
+        return (w, v) => w.writeInt256(BigInt(v));
+    if (type === 'uint256')
+        return (w, v) => w.writeUInt256(BigInt(v));
+    if (type === 'float32')
+        return (w, v) => w.writeFloat32(Number(v));
+    if (type === 'float64')
+        return (w, v) => w.writeFloat64(Number(v));
+    if (type === 'string')
+        return (w, v) => w.writeString(String(v ?? ''));
+    if (type === 'uuid')
+        return (w, v) => w.writeUUID(String(v));
+    if (type === 'date')
+        return (w, v) => w.writeDate(v);
+    if (type === 'date32')
+        return (w, v) => w.writeDate32(v);
+    if (type === 'datetime')
+        return (w, v) => w.writeDateTime(v);
+    if (type.startsWith('datetime64'))
+        return (w, v) => w.writeDateTime64(v, 3);
+    if (type === 'bool' || type === 'boolean')
+        return (w, v) => w.writeBool(Boolean(v));
+    if (type === 'ipv4')
+        return (w, v) => w.writeIPv4(v);
+    if (type === 'ipv6')
+        return (w, v) => w.writeIPv6(v);
+    return (w, v) => w.writeString(String(v ?? ''));
+}
+export function buildBinaryConfig(columns) {
+    const keyMapping = new Map();
+    const encoders = [];
+    const columnInfos = [];
+    columns.forEach((col, index) => {
+        keyMapping.set(col.propKey, index);
+        keyMapping.set(col.name, index);
+        encoders.push(createBinaryEncoder(col.type, col.isNull));
+        columnInfos.push({
+            name: col.name,
+            type: col.type,
+            isNullable: col.isNull,
+        });
+    });
+    return { columns: columnInfos, keyMapping, encoders };
+}
+export function serializeRowBinary(row, config, writer = new BinaryWriter()) {
+    writer.reset();
+    for (let i = 0; i < config.columns.length; i++) {
+        const col = config.columns[i];
+        const value = row[col.name];
+        config.encoders[i](writer, value);
+    }
+    return writer.toBuffer();
+}
+export function serializeRowsBinary(rows, config) {
+    const estimatedRowSize = config.columns.length * 16;
+    const writer = new BinaryWriter(rows.length * estimatedRowSize);
+    for (const row of rows) {
+        for (let i = 0; i < config.columns.length; i++) {
+            const col = config.columns[i];
+            const value = row[col.name];
+            config.encoders[i](writer, value);
+        }
+    }
+    return writer.toBuffer();
+}
+export function createAccessor(propKey, columnName) {
+    if (propKey === columnName) {
+        return (row) => row[propKey];
+    }
+    return (row) => {
+        const v = row[propKey];
+        return v !== undefined ? v : row[columnName];
+    };
+}
+export function buildOptimizedBinaryConfig(columns, options) {
+    const encoders = [];
+    const accessors = [];
+    const columnInfos = [];
+    for (const col of columns) {
+        encoders.push(createBinaryEncoder(col.type, col.isNull));
+        accessors.push(createAccessor(col.propKey, col.name));
+        columnInfos.push({
+            name: col.name,
+            type: col.type,
+            isNullable: col.isNull,
+        });
+    }
+    return {
+        columns: columnInfos,
+        encoders,
+        accessors,
+        skipValidation: options?.skipValidation
+    };
+}
+export function serializeRowsOptimized(rows, config) {
+    const writer = acquireWriter();
+    try {
+        const { encoders, accessors } = config;
+        const colCount = encoders.length;
+        for (let r = 0; r < rows.length; r++) {
+            const row = rows[r];
+            for (let c = 0; c < colCount; c++) {
+                encoders[c](writer, accessors[c](row));
+            }
+        }
+        return writer.toBuffer();
+    }
+    finally {
+        releaseWriter(writer);
+    }
+}
+export function isNumericHeavySchema(columns) {
+    const numericTypes = ['int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32',
+        'int64', 'uint64', 'float32', 'float64'];
+    let numericCount = 0;
+    for (const col of columns) {
+        const type = col.type.toLowerCase();
+        if (numericTypes.some(t => type === t || type.startsWith(t))) {
+            numericCount++;
+        }
+    }
+    return numericCount > columns.length / 2;
+}
+export function serializeNumericBatch(rows, config, numericIndices) {
+    const rowCount = rows.length;
+    const numericCount = numericIndices.length;
+    const numericBuffer = new Float64Array(rowCount * numericCount);
+    const otherData = [];
+    for (let r = 0; r < rowCount; r++) {
+        const row = rows[r];
+        const otherRow = [];
+        let numIdx = 0;
+        for (let c = 0; c < config.accessors.length; c++) {
+            const value = config.accessors[c](row);
+            if (numericIndices.includes(c)) {
+                numericBuffer[r * numericCount + numIdx] = Number(value) || 0;
+                numIdx++;
+            }
+            else {
+                otherRow.push(value);
+            }
+        }
+        otherData.push(otherRow);
+    }
+    return { numericBuffer: numericBuffer.buffer, otherData };
+}

package/dist/utils/binary-worker-code.js

@@ -0,0 +1 @@
+export const binaryWorkerCode = "var{defineProperty:i,getOwnPropertyNames:g0,getOwnPropertyDescriptor:M0}=Object,h0=Object.prototype.hasOwnProperty;var m0=new WeakMap,b0=(f)=>{var x=m0.get(f),U;if(x)return x;if(x=i({},\"__esModule\",{value:!0}),f&&typeof f===\"object\"||typeof f===\"function\")g0(f).map((m)=>!h0.call(x,m)&&i(x,m,{get:()=>f[m],enumerable:!(U=M0(f,m))||U.enumerable}));return m0.set(f,x),x};var o0=(f,x)=>{for(var U in x)i(f,U,{get:x[U],enumerable:!0,configurable:!0,set:(m)=>x[U]=()=>m})};var L=(f,x)=>()=>(f&&(x=f(f=0)),x);var A0=\"ffffffff-ffff-ffff-ffff-ffffffffffff\";var D0=\"00000000-0000-0000-0000-000000000000\";var S0;var V0=L(()=>{S0=/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i});function B0(f){return typeof f===\"string\"&&S0.test(f)}var Z;var C=L(()=>{V0();Z=B0});function p0(f){if(!Z(f))throw TypeError(\"Invalid UUID\");let x;return Uint8Array.of((x=parseInt(f.slice(0,8),16))>>>24,x>>>16&255,x>>>8&255,x&255,(x=parseInt(f.slice(9,13),16))>>>8,x&255,(x=parseInt(f.slice(14,18),16))>>>8,x&255,(x=parseInt(f.slice(19,23),16))>>>8,x&255,(x=parseInt(f.slice(24,36),16))/1099511627776&255,x/4294967296&255,x>>>24&255,x>>>16&255,x>>>8&255,x&255)}var N;var F=L(()=>{C();N=p0});function X(f,x=0){return(_[f[x+0]]+_[f[x+1]]+_[f[x+2]]+_[f[x+3]]+\"-\"+_[f[x+4]]+_[f[x+5]]+\"-\"+_[f[x+6]]+_[f[x+7]]+\"-\"+_[f[x+8]]+_[f[x+9]]+\"-\"+_[f[x+10]]+_[f[x+11]]+_[f[x+12]]+_[f[x+13]]+_[f[x+14]]+_[f[x+15]]).toLowerCase()}function y0(f,x=0){let U=X(f,x);if(!Z(U))throw TypeError(\"Stringified UUID is invalid\");return U}var _,R0;var Q=L(()=>{C();_=[];for(let f=0;f<256;++f)_.push((f+256).toString(16).slice(1));R0=y0});import{randomFillSync as i0}from\"node:crypto\";function Y(){if(M>h.length-16)i0(h),M=0;return h.slice(M,M+=16)}var h,M;var b=L(()=>{h=new Uint8Array(256),M=h.length});function c0(f,x,U){let m,A=f?._v6??!1;if(f){let D=Object.keys(f);if(D.length===1&&D[0]===\"_v6\")f=void 0}if(f)m=$0(f.random??f.rng?.()??Y(),f.msecs,f.nsecs,f.clockseq,f.node,x,U);else{let D=Date.now(),R=Y();w0(K,D,R),m=$0(R,K.msecs,K.nsecs,A?void 0:K.clockseq,A?void 0:K.node,x,U)}return x??X(m)}function w0(f,x,U){if(f.msecs??=-1/0,f.nsecs??=0,x===f.msecs){if(f.nsecs++,f.nsecs>=1e4)f.node=void 0,f.nsecs=0}else if(x>f.msecs)f.nsecs=0;else if(x<f.msecs)f.node=void 0;if(!f.node)f.node=U.slice(10,16),f.node[0]|=1,f.clockseq=(U[8]<<8|U[9])&16383;return f.msecs=x,f}function $0(f,x,U,m,A,D,R=0){if(f.length<16)throw Error(\"Random bytes length must be >= 16\");if(!D)D=new Uint8Array(16),R=0;else if(R<0||R+16>D.length)throw RangeError(`UUID byte range ${R}:${R+15} is out of buffer bounds`);x??=Date.now(),U??=0,m??=(f[8]<<8|f[9])&16383,A??=f.slice(10,16),x+=12219292800000;let q=((x&268435455)*1e4+U)%4294967296;D[R++]=q>>>24&255,D[R++]=q>>>16&255,D[R++]=q>>>8&255,D[R++]=q&255;let H=x/4294967296*1e4&268435455;D[R++]=H>>>8&255,D[R++]=H&255,D[R++]=H>>>24&15|16,D[R++]=H>>>16&255,D[R++]=m>>>8|128,D[R++]=m&255;for(let n=0;n<6;++n)D[R++]=A[n];return D}var K,o;var w=L(()=>{b();Q();K={};o=c0});function z(f){let x=typeof f===\"string\"?N(f):f,U=r0(x);return typeof f===\"string\"?X(U):U}function r0(f){return Uint8Array.of((f[6]&15)<<4|f[7]>>4&15,(f[7]&15)<<4|(f[4]&240)>>4,(f[4]&15)<<4|(f[5]&240)>>4,(f[5]&15)<<4|(f[0]&240)>>4,(f[0]&15)<<4|(f[1]&240)>>4,(f[1]&15)<<4|(f[2]&240)>>4,96|f[2]&15,f[3],f[8],f[9],f[10],f[11],f[12],f[13],f[14],f[15])}var r=L(()=>{F();Q()});import{createHash as t0}from\"node:crypto\";function s0(f){if(Array.isArray(f))f=Buffer.from(f);else if(typeof f===\"string\")f=Buffer.from(f,\"utf8\");return t0(\"md5\").update(f).digest()}var L0;var H0=L(()=>{L0=s0});function u0(f){f=unescape(encodeURIComponent(f));let x=new Uint8Array(f.length);for(let U=0;U<f.length;++U)x[U]=f.charCodeAt(U);return x}function P(f,x,U,m,A,D){let R=typeof U===\"string\"?u0(U):U,q=typeof m===\"string\"?N(m):m;if(typeof m===\"string\")m=N(m);if(m?.length!==16)throw TypeError(\"Namespace must be array-like (16 iterable integer values, 0-255)\");let H=new Uint8Array(16+R.length);if(H.set(q),H.set(R,q.length),H=x(H),H[6]=H[6]&15|f,H[8]=H[8]&63|128,A){D=D||0;for(let n=0;n<16;++n)A[D+n]=H[n];return A}return X(H)}var B=\"6ba7b810-9dad-11d1-80b4-00c04fd430c8\",p=\"6ba7b811-9dad-11d1-80b4-00c04fd430c8\";var t=L(()=>{F();Q()});function s(f,x,U,m){return P(48,L0,f,x,U,m)}var _0;var I0=L(()=>{H0();t();s.DNS=B;s.URL=p;_0=s});import{randomUUID as l0}from\"node:crypto\";var u;var X0=L(()=>{u={randomUUID:l0}});function v0(f,x,U){f=f||{};let m=f.random??f.rng?.()??Y();if(m.length<16)throw Error(\"Random bytes length must be >= 16\");if(m[6]=m[6]&15|64,m[8]=m[8]&63|128,x){if(U=U||0,U<0||U+16>x.length)throw RangeError(`UUID byte range ${U}:${U+15} is out of buffer bounds`);for(let A=0;A<16;++A)x[U+A]=m[A];return x}return X(m)}function a0(f,x,U){if(u.randomUUID&&!x&&!f)return u.randomUUID();return v0(f,x,U)}var j0;var n0=L(()=>{X0();b();Q();j0=a0});import{createHash as e0}from\"node:crypto\";function f1(f){if(Array.isArray(f))f=Buffer.from(f);else if(typeof f===\"string\")f=Buffer.from(f,\"utf8\");return e0(\"sha1\").update(f).digest()}var q0;var J0=L(()=>{q0=f1});function l(f,x,U,m){return P(80,q0,f,x,U,m)}var N0;var Q0=L(()=>{J0();t();l.DNS=B;l.URL=p;N0=l});function x1(f,x,U){f??={},U??=0;let m=o({...f,_v6:!0},new Uint8Array(16));if(m=z(m),x){for(let A=0;A<16;A++)x[U+A]=m[A];return x}return X(m)}var Y0;var T0=L(()=>{Q();w();r();Y0=x1});function v(f){let x=typeof f===\"string\"?N(f):f,U=U1(x);return typeof f===\"string\"?X(U):U}function U1(f){return Uint8Array.of((f[3]&15)<<4|f[4]>>4&15,(f[4]&15)<<4|(f[5]&240)>>4,(f[5]&15)<<4|f[6]&15,f[7],(f[1]&15)<<4|(f[2]&240)>>4,(f[2]&15)<<4|(f[3]&240)>>4,16|(f[0]&240)>>4,(f[0]&15)<<4|(f[1]&240)>>4,f[8],f[9],f[10],f[11],f[12],f[13],f[14],f[15])}var G0=L(()=>{F();Q()});function m1(f,x,U){let m;if(f)m=Z0(f.random??f.rng?.()??Y(),f.msecs,f.seq,x,U);else{let A=Date.now(),D=Y();A1(a,A,D),m=Z0(D,a.msecs,a.seq,x,U)}return x??X(m)}function A1(f,x,U){if(f.msecs??=-1/0,f.seq??=0,x>f.msecs)f.seq=U[6]<<23|U[7]<<16|U[8]<<8|U[9],f.msecs=x;else if(f.seq=f.seq+1|0,f.seq===0)f.msecs++;return f}function Z0(f,x,U,m,A=0){if(f.length<16)throw Error(\"Random bytes length must be >= 16\");if(!m)m=new Uint8Array(16),A=0;else if(A<0||A+16>m.length)throw RangeError(`UUID byte range ${A}:${A+15} is out of buffer bounds`);return x??=Date.now(),U??=f[6]*127<<24|f[7]<<16|f[8]<<8|f[9],m[A++]=x/1099511627776&255,m[A++]=x/4294967296&255,m[A++]=x/16777216&255,m[A++]=x/65536&255,m[A++]=x/256&255,m[A++]=x&255,m[A++]=112|U>>>28&15,m[A++]=U>>>20&255,m[A++]=128|U>>>14&63,m[A++]=U>>>6&255,m[A++]=U<<2&255|f[10]&3,m[A++]=f[11],m[A++]=f[12],m[A++]=f[13],m[A++]=f[14],m[A++]=f[15],m}var a,O0;var C0=L(()=>{b();Q();a={};O0=m1});function D1(f){if(!Z(f))throw TypeError(\"Invalid UUID\");return parseInt(f.slice(14,15),16)}var F0;var K0=L(()=>{C();F0=D1});var z0={};o0(z0,{version:()=>F0,validate:()=>Z,v7:()=>O0,v6ToV1:()=>v,v6:()=>Y0,v5:()=>N0,v4:()=>j0,v3:()=>_0,v1ToV6:()=>z,v1:()=>o,stringify:()=>R0,parse:()=>N,NIL:()=>D0,MAX:()=>A0});var P0=L(()=>{F();Q();w();r();I0();n0();Q0();T0();G0();C0();C();K0()});import{parentPort as W,workerData as k0}from\"worker_threads\";var S1=typeof crypto<\"u\"&&typeof crypto.randomUUID===\"function\",y=null;function V1(){if(S1)return crypto.randomUUID();if(y)return y();return y=(P0(),b0(z0)).v4,y()}class f0{buffer;offset=0;constructor(f=4096){this.buffer=Buffer.allocUnsafe(f)}ensureCapacity(f){let x=this.offset+f;if(x>this.buffer.length){let U=Math.max(this.buffer.length*2,x),m=Buffer.allocUnsafe(U);this.buffer.copy(m,0,0,this.offset),this.buffer=m}}reset(){this.offset=0}getBuffer(){return this.buffer.subarray(0,this.offset)}toBuffer(){return Buffer.from(this.buffer.subarray(0,this.offset))}writeInt8(f){this.ensureCapacity(1),this.buffer.writeInt8(f,this.offset),this.offset+=1}writeUInt8(f){this.ensureCapacity(1),this.buffer.writeUInt8(f,this.offset),this.offset+=1}writeInt16(f){this.ensureCapacity(2),this.buffer.writeInt16LE(f,this.offset),this.offset+=2}writeUInt16(f){this.ensureCapacity(2),this.buffer.writeUInt16LE(f,this.offset),this.offset+=2}writeInt32(f){this.ensureCapacity(4),this.buffer.writeInt32LE(f,this.offset),this.offset+=4}writeUInt32(f){this.ensureCapacity(4),this.buffer.writeUInt32LE(f,this.offset),this.offset+=4}writeInt64(f){this.ensureCapacity(8),this.buffer.writeBigInt64LE(BigInt(f),this.offset),this.offset+=8}writeUInt64(f){this.ensureCapacity(8),this.buffer.writeBigUInt64LE(BigInt(f),this.offset),this.offset+=8}writeInt128(f){this.ensureCapacity(16);let x=f&BigInt(\"0xFFFFFFFFFFFFFFFF\"),U=f>>BigInt(64);this.buffer.writeBigUInt64LE(x,this.offset),this.buffer.writeBigInt64LE(U,this.offset+8),this.offset+=16}writeUInt128(f){this.ensureCapacity(16);let x=f&BigInt(\"0xFFFFFFFFFFFFFFFF\"),U=f>>BigInt(64);this.buffer.writeBigUInt64LE(x,this.offset),this.buffer.writeBigUInt64LE(U,this.offset+8),this.offset+=16}writeInt256(f){this.ensureCapacity(32);for(let x=0;x<4;x++){let U=f&BigInt(\"0xFFFFFFFFFFFFFFFF\");this.buffer.writeBigUInt64LE(U,this.offset+x*8),f>>=BigInt(64)}this.offset+=32}writeUInt256(f){this.writeInt256(f)}writeFloat32(f){this.ensureCapacity(4),this.buffer.writeFloatLE(f,this.offset),this.offset+=4}writeFloat64(f){this.ensureCapacity(8),this.buffer.writeDoubleLE(f,this.offset),this.offset+=8}writeVarInt(f){if(f<128){this.ensureCapacity(1),this.buffer[this.offset++]=f;return}if(f<16384){this.ensureCapacity(2),this.buffer[this.offset++]=f&127|128,this.buffer[this.offset++]=f>>7;return}if(f<2097152){this.ensureCapacity(3),this.buffer[this.offset++]=f&127|128,this.buffer[this.offset++]=f>>7&127|128,this.buffer[this.offset++]=f>>14;return}this.ensureCapacity(10);while(f>=128)this.buffer[this.offset++]=f&127|128,f>>>=7;this.buffer[this.offset++]=f}writeString(f){let x=Buffer.from(f,\"utf-8\");this.writeVarInt(x.length),this.ensureCapacity(x.length),x.copy(this.buffer,this.offset),this.offset+=x.length}writeFixedString(f,x){this.ensureCapacity(x);let U=Buffer.from(f,\"utf-8\"),m=Math.min(U.length,x);if(U.copy(this.buffer,this.offset,0,m),m<x)this.buffer.fill(0,this.offset+m,this.offset+x);this.offset+=x}writeBytes(f){this.ensureCapacity(f.length),f.copy(this.buffer,this.offset),this.offset+=f.length}writeUUID(f){this.ensureCapacity(16);let x=f.replace(/-/g,\"\");if(x.length!==32)throw Error(`Invalid UUID: ${f}`);let U=Buffer.from(x,\"hex\");for(let m=7;m>=0;m--)this.buffer[this.offset++]=U[m];for(let m=15;m>=8;m--)this.buffer[this.offset++]=U[m]}writeDate(f){let x=typeof f===\"number\"?f:Math.floor(f.getTime()/86400000);this.writeUInt16(x)}writeDate32(f){let x=typeof f===\"number\"?f:Math.floor(f.getTime()/86400000);this.writeInt32(x)}writeDateTime(f){let x=typeof f===\"number\"?f:Math.floor(f.getTime()/1000);this.writeUInt32(x)}writeDateTime64(f,x=3){let U=Math.pow(10,x),m=typeof f===\"number\"?BigInt(Math.round(f*U)):BigInt(Math.round(f.getTime()*U/1000));this.writeInt64(m)}writeNullable(f){this.writeUInt8(f?1:0)}writeArrayLength(f){this.writeUInt64(f)}writeDecimal32(f,x){let U=Math.round(f*Math.pow(10,x));this.writeInt32(U)}writeDecimal64(f,x){let U=BigInt(Math.round(f*Math.pow(10,x)));this.writeInt64(U)}writeDecimal128(f,x){let U;if(typeof f===\"bigint\")U=f*BigInt(Math.pow(10,x));else U=BigInt(Math.round(f*Math.pow(10,x)));this.writeInt128(U)}writeBool(f){this.writeUInt8(f?1:0)}writeIPv4(f){if(typeof f===\"number\"){this.writeUInt32(f);return}let x=f.split(\".\").map(Number);if(x.length!==4)throw Error(`Invalid IPv4: ${f}`);let U=x[0]<<24|x[1]<<16|x[2]<<8|x[3];this.writeUInt32(U>>>0)}writeIPv6(f){if(Buffer.isBuffer(f)){if(f.length!==16)throw Error(\"IPv6 must be 16 bytes\");this.writeBytes(f);return}let U=this.expandIPv6(f).split(\":\");this.ensureCapacity(16);for(let m of U){let A=parseInt(m,16);this.buffer.writeUInt16BE(A,this.offset),this.offset+=2}}expandIPv6(f){let x=f.split(\"::\");if(x.length===1)return f;let U=x[0]?x[0].split(\":\"):[],m=x[1]?x[1].split(\":\"):[],A=8-U.length-m.length,D=Array(A).fill(\"0000\");return[...U,...D,...m].map((R)=>R.padStart(4,\"0\")).join(\":\")}writeEnum8(f){this.writeInt8(f)}writeEnum16(f){this.writeInt16(f)}}function e(f){let x=[],U=\"\",m=0;for(let A=0;A<f.length;A++){let D=f[A];if(D===\",\"&&m===0)x.push(U.trim()),U=\"\";else{if(D===\"(\")m++;if(D===\")\")m--;U+=D}}if(U.trim())x.push(U.trim());return x}function T(f,x=!1){let U=f.toLowerCase().trim(),m=U.match(/^nullable\\((.+)\\)$/);if(m){let V=T(m[1],!1);return(S,$)=>{if($===null||$===void 0)S.writeNullable(!0);else S.writeNullable(!1),V(S,$)}}let A=U.match(/^array\\((.+)\\)$/);if(A){let V=T(A[1],!1);return(S,$)=>{let J=Array.isArray($)?$:[];S.writeArrayLength(J.length);for(let j of J)V(S,j)}}let D=U.match(/^map\\((.+)\\)$/);if(D){let[V,S]=e(D[1]);if(!V||!S)throw Error(`Invalid Map type: ${U}`);let $=T(V),J=T(S);return(j,I)=>{let G;if(I instanceof Map)G=Array.from(I.entries());else if(typeof I===\"object\"&&I!==null)G=Object.entries(I);else G=[];j.writeUInt64(G.length);for(let[O,g]of G)$(j,O),J(j,g)}}let R=U.match(/^tuple\\((.+)\\)$/);if(R){let S=e(R[1]).map(($)=>T($));return($,J)=>{let j=Array.isArray(J)?J:[];for(let I=0;I<S.length;I++)S[I]($,j[I])}}let q=U.match(/^nested\\((.+)\\)$/);if(q){let V=e(q[1]),$=`Tuple(${V.map((j)=>{let I=j.trim().split(/\\s+/);if(I.length<2)return\"String\";return I.slice(1).join(\" \")}).join(\", \")})`,J=T($);return(j,I)=>{let G=Array.isArray(I)?I:[];j.writeArrayLength(G.length);for(let O of G){let g=O;if(!Array.isArray(O)&&typeof O===\"object\")g=V.map((W0)=>{let d0=W0.trim().split(/\\s+/)[0];return O[d0]});J(j,g)}}}let H=U.match(/^lowcardinality\\((.+)\\)$/);if(H)return T(H[1]);let n=U.match(/^fixedstring\\((\\d+)\\)$/);if(n){let V=parseInt(n[1],10);return(S,$)=>{S.writeFixedString(String($??\"\"),V)}}let x0=U.match(/^decimal(?:32|64|128)?\\((\\d+),\\s*(\\d+)\\)$/);if(x0){let V=parseInt(x0[2],10);if(U.includes(\"decimal128\"))return(S,$)=>S.writeDecimal128($,V);if(U.includes(\"decimal64\"))return(S,$)=>S.writeDecimal64($,V);return(S,$)=>S.writeDecimal32($,V)}let U0=U.match(/^datetime64\\((\\d+)/);if(U0){let V=parseInt(U0[1],10);return(S,$)=>S.writeDateTime64($,V)}if(U.match(/^enum8\\(/))return(V,S)=>V.writeEnum8(Number(S));if(U.match(/^enum16\\(/))return(V,S)=>V.writeEnum16(Number(S));let d=R1(U);if(x)return(V,S)=>{if(S===null||S===void 0)V.writeNullable(!0);else V.writeNullable(!1),d(V,S)};if(U===\"uuid\")return(V,S)=>{if(S===void 0||S===null)d(V,V1());else d(V,S)};return d}function R1(f){if(f===\"int8\")return(x,U)=>x.writeInt8(Number(U));if(f===\"uint8\")return(x,U)=>x.writeUInt8(Number(U));if(f===\"int16\")return(x,U)=>x.writeInt16(Number(U));if(f===\"uint16\")return(x,U)=>x.writeUInt16(Number(U));if(f===\"int32\")return(x,U)=>x.writeInt32(Number(U));if(f===\"uint32\")return(x,U)=>x.writeUInt32(Number(U));if(f===\"int64\")return(x,U)=>x.writeInt64(U);if(f===\"uint64\")return(x,U)=>x.writeUInt64(U);if(f===\"int128\")return(x,U)=>x.writeInt128(BigInt(U));if(f===\"uint128\")return(x,U)=>x.writeUInt128(BigInt(U));if(f===\"int256\")return(x,U)=>x.writeInt256(BigInt(U));if(f===\"uint256\")return(x,U)=>x.writeUInt256(BigInt(U));if(f===\"float32\")return(x,U)=>x.writeFloat32(Number(U));if(f===\"float64\")return(x,U)=>x.writeFloat64(Number(U));if(f===\"string\")return(x,U)=>x.writeString(String(U??\"\"));if(f===\"uuid\")return(x,U)=>x.writeUUID(String(U));if(f===\"date\")return(x,U)=>x.writeDate(U);if(f===\"date32\")return(x,U)=>x.writeDate32(U);if(f===\"datetime\")return(x,U)=>x.writeDateTime(U);if(f.startsWith(\"datetime64\"))return(x,U)=>x.writeDateTime64(U,3);if(f===\"bool\"||f===\"boolean\")return(x,U)=>x.writeBool(Boolean(U));if(f===\"ipv4\")return(x,U)=>x.writeIPv4(U);if(f===\"ipv6\")return(x,U)=>x.writeIPv6(U);return(x,U)=>x.writeString(String(U??\"\"))}var k=null,E=null;function $1(f,x){if(!k||!E)throw Error(\"Worker not configured\");E.reset();for(let U of f)for(let m=0;m<k.columns.length;m++){let A=k.columns[m],D=U[A.name];k.encoders[m](E,D)}return E.toBuffer()}function E0(f){try{switch(f.type){case\"configure\":{let x=f.columns.map((U)=>T(U.type,U.isNullable));k={columns:f.columns,keyMapping:new Map,encoders:x},E=new f0(1048576),W?.postMessage({type:\"ready\"});break}case\"serialize\":{let x=$1(f.rows,f.batchId),U=new ArrayBuffer(x.length);new Uint8Array(U).set(x),W?.postMessage({type:\"result\",batchId:f.batchId,buffer:Buffer.from(U),rowCount:f.rows.length},[U]);break}case\"shutdown\":process.exit(0)}}catch(x){W?.postMessage({type:\"error\",batchId:f.batchId,error:x instanceof Error?x.message:String(x)})}}if(W){if(W.on(\"message\",E0),k0?.columns)E0({type:\"configure\",columns:k0.columns})}\n";