import fs from 'fs'
import pg from 'pg'

function createPool() {
  const pool = new pg.Pool({
    user: 'postgres',
    host: 'X.X.X.X',
    database: 'stagingDb',
    password: '...',
    port: 5432,
    max: 40,
  })
  return pool
}

// Function to read SQL queries from a file
function readSqlFromFile(filePath) {
  return new Promise((resolve, reject) => {
    fs.readFile(filePath, { encoding: 'utf-8' }, (err, data) => {
      if (err) reject(err)
      else resolve(data)
    })
  })
}

// Function to execute a chunk of queries concurrently
async function executeQueryChunk(pool, queries) {
  await Promise.all(
    queries.map((query) => {
      if (query) {
        return pool.query(query)
      }
      return Promise.reject()
    })
  )
}

// Function to execute your queries
async function executeQueries(filePath, concurrencyLimit) {
  console.log('\nConcurrency:', concurrencyLimit)

  const pool = createPool()

  try {
    const queriesString = await readSqlFromFile(filePath)
    const queries = queriesString
      .split(';') // Splitting queries by ';'
      .map((query) => query.trim())
      .filter((query) => query) // Ensure no empty queries

    const start = Date.now()

    for (let i = 0; i < queries.length; i += concurrencyLimit) {
      // Create a chunk of queries to run concurrently
      const queryChunk = queries.slice(i, i + concurrencyLimit)
      await executeQueryChunk(pool, queryChunk)
    }

    const end = Date.now()
    console.log(`Execution time: ${((end - start) / 1000).toFixed(4)} seconds`)

    console.log('All queries executed successfully.')
  } catch (error) {
    console.error('Error executing queries:', error)
  } finally {
    await pool.end() // Close the pool
  }
}

const concurrencyLimits = [10, 20, 40, 80, 160]
for (const limit of concurrencyLimits) {
  await executeQueries('./benchmark.sql', limit)
}

import { PrismaClient } from '@prisma/client'

function createClient() {
  const client = new PrismaClient({
    datasources: {
      db: {
        url: 'postgresql://postgres:[email protected]:5432/stagingDb?connection_limit=40',
      },
    },
  })
  return client
}

// Function to execute a chunk of queries concurrently
async function executeQueryChunk(client, queries) {
  await Promise.all(
    queries.map((query) => {
      if (query) {
        return client.$queryRawUnsafe(query)
      }
      return Promise.reject()
    })
  )
}

// ...

const client = createClient()
await client.$connect()