@dbcube/core 3.0.9 → 3.0.12

package/dist/index.d.mts

@@ -45,10 +45,14 @@ declare class QueryEngine {
     private waitForServerReady;
     private isServerResponding;
     private sleep;
+    private initializeConnectionPool;
     private getCachedDML;
     private startTcpServer;
     private sendTcpRequest;
     private sendTcpRequestFast;
+    private sendUltraFast;
+    private createAndPoolConnection;
+    private createPooledConnection;
     private sendOnExistingConnection;
     private createPersistentConnection;
     private createProcess;

package/dist/index.d.ts

@@ -45,10 +45,14 @@ declare class QueryEngine {
     private waitForServerReady;
     private isServerResponding;
     private sleep;
+    private initializeConnectionPool;
     private getCachedDML;
     private startTcpServer;
     private sendTcpRequest;
     private sendTcpRequestFast;
+    private sendUltraFast;
+    private createAndPoolConnection;
+    private createPooledConnection;
     private sendOnExistingConnection;
     private createPersistentConnection;
     private createProcess;

package/dist/index.js

@@ -730,9 +730,39 @@ import * as net from "net";
 import { spawn as spawn2 } from "child_process";
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
-var queryCache = /* @__PURE__ */ new Map();
-var cacheSize = 0;
-var MAX_CACHE_SIZE = 500;
+var connectionPools = /* @__PURE__ */ new Map();
+var MAX_POOL_SIZE = 3;
+var LRUCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  constructor(maxSize) {
+    this.maxSize = maxSize;
+  }
+  get(key) {
+    if (this.cache.has(key)) {
+      const value = this.cache.get(key);
+      this.cache.delete(key);
+      this.cache.set(key, value);
+      return value;
+    }
+    return void 0;
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.cache.delete(key);
+    } else if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== void 0) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  size() {
+    return this.cache.size;
+  }
+};
+var queryCache = new LRUCache(500);
 var QueryEngine = class {
   name;
   config;
@@ -849,11 +879,10 @@ var QueryEngine = class {
   async executeWithTcpServer(args) {
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
-      console.log("\u{1F680} Starting TCP server for ultra-fast queries...");
       await this.startTcpServer();
       await this.waitForServerReady();
+      await this.initializeConnectionPool();
     }
-    console.log("\u26A1 Using TCP server (ultra-fast)");
     return this.sendTcpRequestFast(args);
   }
   async waitForServerReady() {
@@ -863,7 +892,6 @@ var QueryEngine = class {
       if (await this.isServerResponding()) {
         return;
       }
-      console.log(`\u23F3 Waiting for TCP server to be ready... (${i + 1}/${maxRetries})`);
       await this.sleep(retryDelay);
     }
     throw new Error("TCP server failed to become ready within timeout");
@@ -889,15 +917,30 @@ var QueryEngine = class {
   sleep(ms) {
     return new Promise((resolve5) => setTimeout(resolve5, ms));
   }
+  async initializeConnectionPool() {
+    console.log("\u{1F3CA} Initializing connection pool...");
+    if (!connectionPools.has(this.connectionId)) {
+      connectionPools.set(this.connectionId, []);
+    }
+    const pool = connectionPools.get(this.connectionId);
+    for (let i = 0; i < MAX_POOL_SIZE; i++) {
+      try {
+        const connection = await this.createPooledConnection();
+        pool.push(connection);
+        console.log(`\u2705 Pool connection ${i + 1}/${MAX_POOL_SIZE} created`);
+      } catch (error) {
+        console.error(`\u274C Failed to create pool connection ${i + 1}:`, error);
+      }
+    }
+    console.log(`\u{1F680} Connection pool ready with ${pool.length} connections`);
+  }
   getCachedDML(dmlJson) {
-    if (queryCache.has(dmlJson)) {
-      return queryCache.get(dmlJson);
+    const cached = queryCache.get(dmlJson);
+    if (cached) {
+      return cached;
     }
     const parsed = JSON.parse(dmlJson);
-    if (cacheSize < MAX_CACHE_SIZE) {
-      queryCache.set(dmlJson, parsed);
-      cacheSize++;
-    }
+    queryCache.set(dmlJson, parsed);
     return parsed;
   }
   async startTcpServer() {
@@ -906,7 +949,6 @@ var QueryEngine = class {
       throw new Error("Binary not initialized");
     }
     this.tcpPort = await this.findAvailablePort(this.tcpPort);
-    console.log(`\u{1F310} Using port ${this.tcpPort} for TCP server`);
     return new Promise((resolve5, reject) => {
       const serverArgs = [...this.arguments, "--action", "server", "--port", this.tcpPort.toString()];
       const serverProcess = spawn2(this.binary["query_engine"], serverArgs);
@@ -919,7 +961,6 @@ var QueryEngine = class {
       }, 15e3);
       serverProcess.stdout.on("data", (data) => {
         const output = data.toString();
-        console.log(`[TCP Server] ${output.trim()}`);
         if (output.includes("TCP Server listening on")) {
           if (!started) {
             started = true;
@@ -936,7 +977,6 @@ var QueryEngine = class {
         console.error(`[TCP Server Error] ${data.toString().trim()}`);
       });
       serverProcess.on("close", (code) => {
-        console.log(`[TCP Server] Process exited with code ${code}`);
         globalTcpServers.delete(this.connectionId);
       });
       serverProcess.on("error", (error) => {
@@ -1014,16 +1054,100 @@ var QueryEngine = class {
     });
   }
   async sendTcpRequestFast(args) {
-    const existingConnection = globalTcpConnections.get(this.connectionId);
-    if (existingConnection && existingConnection.readyState === "open") {
+    if (!connectionPools.has(this.connectionId)) {
+      return await this.createAndPoolConnection(args);
+    }
+    const pool = connectionPools.get(this.connectionId);
+    if (pool.length > 0) {
+      const connection = pool.pop();
       try {
-        return await this.sendOnExistingConnection(existingConnection, args);
+        const result = await this.sendUltraFast(connection, args);
+        pool.push(connection);
+        return result;
       } catch (error) {
-        globalTcpConnections.delete(this.connectionId);
-        existingConnection.destroy();
+        connection.destroy();
+        return await this.createAndPoolConnection(args);
       }
     }
-    return await this.createPersistentConnection(args);
+    return await this.createAndPoolConnection(args);
+  }
+  async sendUltraFast(connection, args) {
+    return new Promise((resolve5, reject) => {
+      const dmlIndex = args.findIndex((arg) => arg === "--dml");
+      const dmlJson = dmlIndex !== -1 ? args[dmlIndex + 1] : null;
+      if (!dmlJson) {
+        reject(new Error("No DML found in arguments"));
+        return;
+      }
+      let responseBuffer = "";
+      let isResolved = false;
+      const timeout = setTimeout(() => {
+        if (!isResolved) {
+          isResolved = true;
+          connection.off("data", onData);
+          connection.off("error", onError);
+          reject(new Error("Ultra-fast timeout"));
+        }
+      }, 50);
+      const onData = (data) => {
+        responseBuffer += data.toString();
+        const match = responseBuffer.match(/PROCESS_RESPONSE:(\{.*\})/);
+        if (match && !isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.off("data", onData);
+          connection.off("error", onError);
+          try {
+            const response = JSON.parse(match[1]);
+            resolve5({
+              status: response.status,
+              message: response.message,
+              data: response.data
+            });
+          } catch (error) {
+            reject(new Error("Failed to parse TCP response"));
+          }
+        }
+      };
+      const onError = (error) => {
+        if (!isResolved) {
+          isResolved = true;
+          clearTimeout(timeout);
+          connection.off("data", onData);
+          connection.off("error", onError);
+          reject(error);
+        }
+      };
+      connection.on("data", onData);
+      connection.on("error", onError);
+      const command = `{"action":"execute","dml":${dmlJson}}`;
+      connection.write(command);
+    });
+  }
+  async createAndPoolConnection(args) {
+    const connection = await this.createPooledConnection();
+    if (!connectionPools.has(this.connectionId)) {
+      connectionPools.set(this.connectionId, []);
+    }
+    const result = await this.sendUltraFast(connection, args);
+    const pool = connectionPools.get(this.connectionId);
+    if (pool.length < MAX_POOL_SIZE) {
+      pool.push(connection);
+    } else {
+      connection.destroy();
+    }
+    return result;
+  }
+  async createPooledConnection() {
+    return new Promise((resolve5, reject) => {
+      const client = new net.Socket();
+      client.setNoDelay(true);
+      client.setKeepAlive(true, 0);
+      client.connect(this.tcpPort, "127.0.0.1", () => {
+        resolve5(client);
+      });
+      client.on("error", reject);
+    });
   }
   async sendOnExistingConnection(connection, args) {
     return new Promise((resolve5, reject) => {
@@ -1033,6 +1157,7 @@ var QueryEngine = class {
         reject(new Error("No DML found in arguments"));
         return;
       }
+      const dmlParsed = this.getCachedDML(dmlJson);
       let responseBuffer = "";
       let isResolved = false;
       const timeout = setTimeout(() => {
@@ -1240,7 +1365,6 @@ var QueryEngine = class {
     }
     const serverInfo = globalTcpServers.get(this.connectionId);
     if (serverInfo && serverInfo.process && !serverInfo.process.killed) {
-      console.log("\u{1F50C} Stopping TCP server...");
       serverInfo.process.kill();
       globalTcpServers.delete(this.connectionId);
       return {