examples/session-pool.ts

/**
 * SessionPool Example
 *
 * This example demonstrates how to use SessionPool for efficient connection
 * management in high-concurrency scenarios, including explicit session management.
 */

import { SessionPool, PoolConfigBuilder, TreeTablet, TSDataType } from "../src";

async function main() {
  console.log("=== SessionPool Example ===\n");

  // Method 1: Traditional constructor (backward compatible)
  console.log("Creating session pool using traditional constructor...");
  const pool1 = new SessionPool("localhost", 6667, {
    username: "root",
    password: "root",
    maxPoolSize: 10,
    minPoolSize: 2,
    maxIdleTime: 60000,
    waitTimeout: 60000,
  });

  // Method 2: Using Builder pattern (recommended)
  console.log("Creating session pool using Builder pattern...");
  const pool2 = new SessionPool(
    new PoolConfigBuilder()
      .host("localhost")
      .port(6667)
      .username("root")
      .password("root")
      .maxPoolSize(10)
      .minPoolSize(2)
      .maxIdleTime(60000)
      .waitTimeout(60000)
      .build(),
  );

  // For demo purposes, we'll use pool1
  const pool = pool1;

  try {
    // Initialize the pool
    console.log("\nInitializing session pool...");
    await pool.init();
    console.log("Pool initialized with", pool.getPoolSize(), "connections");

    // Create database
    console.log("\nCreating database...");
    await pool.executeNonQueryStatement("CREATE DATABASE root.pool_example");

    // Create timeseries
    console.log("Creating timeseries...");
    await pool.executeNonQueryStatement(
      "CREATE TIMESERIES root.pool_example.sensor1.value WITH DATATYPE=FLOAT",
    );

    // Approach 1: Using pool methods directly (automatic session management)
    console.log("\n--- Approach 1: Automatic session management ---");
    console.log("Executing concurrent queries...");
    const promises = [];

    for (let i = 0; i < 20; i++) {
      promises.push(
        pool.executeQueryStatement("SHOW DATABASES").then(async (dataSet) => {
          let count = 0;
          while (await dataSet.hasNext()) {
            dataSet.next();
            count++;
          }
          await dataSet.close();
          console.log(`Query ${i + 1} completed with ${count} rows`);
        }),
      );
    }

    await Promise.all(promises);
    console.log("All concurrent queries completed");

    // Approach 2: Explicit session management (new API)
    console.log("\n--- Approach 2: Explicit session management ---");
    console.log("Getting a session from the pool...");
    const session = await pool.getSession();

    try {
      console.log("Executing operations with explicit session...");

      // Insert data using TreeTablet class with addRow
      const tablet = new TreeTablet(
        "root.pool_example.sensor1",
        ["value"],
        [TSDataType.FLOAT]
      );
      tablet.addRow(Date.now(), [42.5]);
      tablet.addRow(Date.now() + 1000, [43.0]);
      
      await session.insertTablet(tablet);
      console.log("Tree tablet data inserted via explicit session");

      // Query data
      const dataSet = await session.executeQueryStatement(
        "SELECT * FROM root.pool_example.sensor1",
      );
      let rowCount = 0;
      while (await dataSet.hasNext()) {
        dataSet.next();
        rowCount++;
      }
      await dataSet.close();
      console.log("Query result:", rowCount, "rows");
    } finally {
      // Always release the session back to the pool
      pool.releaseSession(session);
      console.log("Session released back to the pool");
    }

    // Check pool statistics
    console.log("\nPool statistics:");
    console.log("Total connections:", pool.getPoolSize());
    console.log("Available connections:", pool.getAvailableSize());
    console.log("In-use connections:", pool.getInUseSize());

    // Enhanced metrics
    console.log("\nEnhanced pool metrics:");
    console.log("Total (new API):", pool.totalCount);
    console.log("Idle (new API):", pool.idleCount);
    console.log("Active (new API):", pool.activeCount);
    console.log("Waiting requests:", pool.waitingCount);

    // Comprehensive statistics
    const stats = pool.getPoolStats();
    console.log("\nComprehensive stats:", stats);

    // Approach 3: Concurrent batch insertion (NEW API)
    console.log("\n--- Approach 3: Concurrent batch insertion (insertTabletsParallel) ---");
    const tablets = [];
    const batchTime = Date.now();
    
    for (let i = 0; i < 20; i++) {
      tablets.push({
        deviceId: `root.pool_example.batch_sensor${i}`,
        measurements: ["value"],
        dataTypes: [TSDataType.FLOAT],
        timestamps: [batchTime + i * 1000],
        values: [[100.0 + i]],
      });
    }

    console.log(`Inserting ${tablets.length} tablets concurrently...`);
    const startTime = Date.now();
    await pool.insertTabletsParallel(tablets, { concurrency: 5 });
    const elapsed = Date.now() - startTime;
    console.log(`Inserted ${tablets.length} tablets in ${elapsed}ms (${(tablets.length * 1000 / elapsed).toFixed(2)} tablets/sec)`);

    // Approach 4: Generic parallel execution (NEW API)
    console.log("\n--- Approach 4: Generic parallel execution (executeParallel) ---");
    const deviceNames = ["parallel_d1", "parallel_d2", "parallel_d3", "parallel_d4"];
    
    console.log(`Creating ${deviceNames.length} timeseries in parallel...`);
    const results = await pool.executeParallel(
      deviceNames,
      async (session, deviceName) => {
        try {
          await session.executeNonQueryStatement(
            `CREATE TIMESERIES root.pool_example.${deviceName}.value WITH DATATYPE=FLOAT`
          );
        } catch {
          // Ignore if already exists
        }
        return `Created ${deviceName}`;
      },
      { concurrency: 4 }
    );
    console.log("Results:", results);

  } catch (error) {
    console.error("Error:", error);
  } finally {
    // Close the pool
    console.log("\nClosing session pool...");
    await pool.close();
    console.log("Pool closed");
  }
}

main().catch(console.error);