How to Pass a PostgreSQL Array Without Unwanted Quotes in n8n's SQL Tool?

Below is an explanation with a suggested solution:

Explanation

The issue you’re experiencing is because the $fromAI() output is being treated as a string. In other words, when you use an expression like:

JAVASCRIPTCopied
{{ $fromAI("id_table") }}

n8n sanitizes the value and automatically adds quotes. This causes the output to look like:

'ARRAY[1','2]'

instead of the raw, unquoted:

ARRAY[1,2]

which PostgreSQL expects for an array literal.

How to Resolve

To avoid this problem you have two main options:

1. Build the Query Using Query Parameters:
   Instead of relying on $fromAI() to inject the array directly into the query, use the Postgres node’s Query Parameters feature. For example, build your query with a placeholder for the array:

   SQLCopied
   SELECT valider_reservation_multi(
     72,
     /* id_client */
     {{ $json.id_client }},
     /* id_tables */
     ARRAY[{{ $json.input_table_ids.map((i, pos) => "$" + (pos + 1)).join(', ') }}],
     /* date_service */
     '2025-02-14',
     /* heure */
     '13:00:00',
     /* service */
     'midi',
     /* sous_service */
     1,
     /* nombre_personnes */
     10,
     /* extra_info */
     NULL
   );

   And then in the Query Parameters field, pass an array of numbers (e.g., [1, 2]). This technique lets n8n correctly build prepared statements without the unwanted quotes.

2. Adjust the Dynamic Value:
   If you must use $fromAI(), consider letting the AI output only the raw values (for example: 1,2), and then manually wrap it with the ARRAY[...] syntax directly in the query. However, note that even if the AI output is numeric, the expression wrapping might still quote the result if not handled carefully.

Tip:
The recommended approach is to rely on query parameters and dynamically create placeholders. This ensures data is correctly sanitized while preserving the correct SQL syntax for arrays.

Final Thoughts

The core of the problem is that $fromAI() is designed to output values in a way that is safe for SQL injection prevention—by treating them as strings. When dealing with PostgreSQL array literals, you have to work around that by either constructing the query with proper query parameters or adjusting your dynamic expression to prevent unwanted quoting.

Using the first option gives you extra protection and better control over how and when the placeholders are inserted into your final query.

Let me know if you need further clarification or another example!