When working with SQL queries in Node.js (for example, using mysql2, pg, or similar libraries), you might come across two seemingly similar snippets:

const [instanceCount] = await query(
  `SELECT COUNT(*) as count 
   FROM instances 
   WHERE user_id = ?`,
  [req.user.id]
);

and

const instanceCount = await query(
  `SELECT COUNT(*) as count 
   FROM instances 
   WHERE user_id = ?`,
  [req.user.id]
);

They look almost identical, but they behave quite differently.
Let’s break it down and understand what’s really going on 👇

🧩 The Core Difference: Destructuring

The difference doesn’t come from SQL — both queries send the exact same statement to your database.

The difference comes from how the JavaScript query() result is handled.

Most Node.js database libraries (like mysql2/promise, pg, or knex.raw()) return an array of rows when you run a query.

Let’s see what that means.

1️⃣ Example 1 — Using Array Destructuring

const [instanceCount] = await query(
  `SELECT COUNT(*) as count 
   FROM instances 
   WHERE user_id = ?`,
  [req.user.id]
);

What happens:

When your query runs, the database returns one row:

[ { count: 3 } ]

By using array destructuring ([instanceCount]), you immediately extract the first (and only) element of that array.

So the variable now looks like this:

instanceCount = { count: 3 };

To access the count:

console.log(instanceCount.count); // → 3

✅ This approach is clean, direct, and ideal when you expect a single-row result, such as a COUNT(), LIMIT 1, or SELECT ... WHERE id = ?.

2️⃣ Example 2 — Without Destructuring

const instanceCount = await query(
  `SELECT COUNT(*) as count 
   FROM instances 
   WHERE user_id = ?`,
  [req.user.id]
);

What happens:

Here, you’re assigning the entire array returned by the query:

instanceCount = [ { count: 3 } ];

So to access the count value, you’d need to reference the first element manually:

console.log(instanceCount[0].count); // → 3

It works just fine — but it’s a bit more verbose.

🧠 Summary Table

✅ Best Practice

Whenever you expect exactly one record, use array destructuring.
It keeps your code shorter, clearer, and avoids unnecessary [0] lookups.

const [instanceCount] = await query(
  'SELECT COUNT(*) AS count FROM instances WHERE user_id = ?',
  [req.user.id]
);

console.log(instanceCount.count); // clean and readable

⚙️ Bonus: Safe Fallback

If there’s a chance your query returns no rows, you can handle it safely like this:

const [instanceCount] = await query(
  'SELECT COUNT(*) AS count FROM instances WHERE user_id = ?',
  [req.user.id]
);

const total = instanceCount?.count ?? 0;
console.log('Total instances:', total);

This ensures your code doesn’t throw errors when no results are returned.

🏁 Final Thoughts

The key takeaway:

Array destructuring in JavaScript isn’t just syntactic sugar — it helps simplify your database query results, especially for single-row operations.

Use [row] when you expect one result, and rows when you expect many.
It’s a small detail, but it can make your code much cleaner and easier to read.