@dbcube/core 3.0.12 → 3.0.15

package/dist/index.cjs

@@ -768,39 +768,9 @@ var net = __toESM(require("net"));
 var import_child_process2 = require("child_process");
 var globalTcpServers = /* @__PURE__ */ new Map();
 var globalTcpConnections = /* @__PURE__ */ new Map();
-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 queryCache = /* @__PURE__ */ new Map();
+var cacheSize = 0;
+var MAX_CACHE_SIZE = 500;
 var QueryEngine = class {
   name;
   config;
@@ -919,7 +889,6 @@ var QueryEngine = class {
     if (!serverInfo || !serverInfo.process || serverInfo.process.killed) {
       await this.startTcpServer();
       await this.waitForServerReady();
-      await this.initializeConnectionPool();
     }
     return this.sendTcpRequestFast(args);
   }
@@ -955,30 +924,15 @@ 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) {
-    const cached = queryCache.get(dmlJson);
-    if (cached) {
-      return cached;
+    if (queryCache.has(dmlJson)) {
+      return queryCache.get(dmlJson);
     }
     const parsed = JSON.parse(dmlJson);
-    queryCache.set(dmlJson, parsed);
+    if (cacheSize < MAX_CACHE_SIZE) {
+      queryCache.set(dmlJson, parsed);
+      cacheSize++;
+    }
     return parsed;
   }
   async startTcpServer() {
@@ -1092,100 +1046,16 @@ var QueryEngine = class {
     });
   }
   async sendTcpRequestFast(args) {
-    if (!connectionPools.has(this.connectionId)) {
-      return await this.createAndPoolConnection(args);
-    }
-    const pool = connectionPools.get(this.connectionId);
-    if (pool.length > 0) {
-      const connection = pool.pop();
+    const existingConnection = globalTcpConnections.get(this.connectionId);
+    if (existingConnection && existingConnection.readyState === "open") {
       try {
-        const result = await this.sendUltraFast(connection, args);
-        pool.push(connection);
-        return result;
+        return await this.sendOnExistingConnection(existingConnection, args);
       } catch (error) {
-        connection.destroy();
-        return await this.createAndPoolConnection(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;
+        globalTcpConnections.delete(this.connectionId);
+        existingConnection.destroy();
       }
-      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);
-    });
+    return await this.createPersistentConnection(args);
   }
   async sendOnExistingConnection(connection, args) {
     return new Promise((resolve5, reject) => {
@@ -1195,7 +1065,6 @@ 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(() => {