Understanding Array Destructuring in Node.js Database Queries

This content originally appeared on DEV Community and was authored by Sospeter Mong’are

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.

This content originally appeared on DEV Community and was authored by Sospeter Mong’are