How to fix Too many arguments in PostgreSQL

PostgreSQLINTERMEDIATEHIGHUpdated Dec 28, 2025· 166 views

PostgreSQL enforces a 100-argument limit on functions. This error occurs when calling functions like json_build_object() with more than 100 arguments, or when passing too many parameters to RAISE statements in PL/pgSQL. Solutions include using array-based approaches or composite data types.

Quick fix

Fixes Too many arguments

-- This will fail with 101+ arguments
SELECT json_build_object(
  'col1', col1, 'col2', col2, ... 'col51', col51
) FROM my_table;
  1. Check your function argument count
  2. Use json_object() with array for large column lists
  3. Convert to composite data types if building complex objects
  4. Fix PL/pgSQL RAISE statements
postgresql — error
-- This will fail with 101+ arguments
SELECT json_build_object(
  'col1', col1, 'col2', col2, ... 'col51', col51
) FROM my_table;
Too many arguments

What this error means

The "Too many arguments" error in PostgreSQL occurs when you attempt to call a function or command with more arguments than it can accept. PostgreSQL has a hard limit of 100 arguments (FUNC_MAX_ARGS) for any function call. This is a design constraint in PostgreSQL to optimize the function call mechanism. The error commonly appears when working with JSON functions like json_build_object() that require key-value pairs, or when using PL/pgSQL RAISE statements with too many parameters. Additionally, this error can occur with command-line utilities like pg_dump if arguments are malformed or improperly passed.

Typical symptoms

  • ERROR: cannot pass more than 100 arguments to a function
  • Function call fails when working with many columns in json_build_object() or json_build_array()
  • RAISE statement errors with "too many parameters specified for raise"
  • Command-line tools like pg_dump fail with "too many command-line arguments"

Common causes

  1. Attempting to pass more than 100 arguments to a single function call (PostgreSQL hard limit)
  2. Using json_build_object() with too many key-value pairs (each column requires 2 arguments: key + value)
  3. Specifying too many parameters for RAISE statement placeholders in PL/pgSQL
  4. Malformed command-line arguments passed to pg_dump or pg_restore utilities

How to fix "Too many arguments"

1Check your function argument count

Count the total number of arguments being passed to your function. Remember that json_build_object() requires two arguments per column (key and value), so 100 arguments limits you to 50 columns.

sql
-- This will fail with 101+ arguments
SELECT json_build_object(
  'col1', col1, 'col2', col2, ... 'col51', col51
) FROM my_table;
2Use json_object() with array for large column lists

Replace json_build_object() with json_object() that accepts an array of key-value pairs. This approach has no argument limit and is more scalable:

sql
-- No argument limit - works with any number of columns
SELECT json_object(
  ARRAY['col1', 'col2', 'col3', ...],
  ARRAY[col1, col2, col3, ...]
) FROM my_table;
3Convert to composite data types if building complex objects

For functions with more than 100 parameters, refactor to use a composite data type or split the function into multiple smaller functions:

sql
-- Define a composite type
CREATE TYPE user_data AS (
  id INT,
  name VARCHAR,
  email VARCHAR,
  ... (up to 100 fields)
);

-- Create function accepting the composite type
CREATE FUNCTION process_user(data user_data) RETURNS VOID AS $$
BEGIN
  -- Process the composite type
END;
$$ LANGUAGE plpgsql;
4Fix PL/pgSQL RAISE statements

Ensure the number of parameters matches the number of placeholders in your RAISE statement:

sql
-- Correct: 3 parameters for 3 %s placeholders
RAISE NOTICE 'Values: %, %, %', var1, var2, var3;

-- Wrong: too many parameters
RAISE NOTICE 'Values: %, %', var1, var2, var3; -- This fails
5Verify command-line arguments for pg_dump

When using pg_dump, ensure all flags have their required values:

bash
# Wrong: -h flag without hostname
pg_dump -h -U admin -p 5432 mydb
# Error: pg_dump: too many command-line arguments (first is "-U")

# Correct: -h followed by hostname
pg_dump -h localhost -U admin -p 5432 mydb

# Or use environment variables instead
PGHOST=localhost PGUSER=admin pg_dump mydb

Advanced notes

The 100-argument limit (FUNC_MAX_ARGS) is a compile-time constant in PostgreSQL that can theoretically be changed by rebuilding PostgreSQL from source, but this is not recommended for production systems. The limit exists to optimize the function call mechanism and parameter passing. When designing database schemas and functions, consider the 100-argument limit early. For large result sets with many columns, using array-based approaches or JSONB columns is more scalable than trying to work around the argument limit. PostgreSQL maintainers recommend using aggregate functions and array/JSON approaches rather than trying to increase the limit.

Frequently asked questions

What does "Too many arguments" mean?
The "Too many arguments" error in PostgreSQL occurs when you attempt to call a function or command with more arguments than it can accept. PostgreSQL has a hard limit of 100 arguments (FUNC_MAX_ARGS) for any function call. This is a design constraint in PostgreSQL to optimize the function call mechanism.
How do I fix "Too many arguments"?
PostgreSQL enforces a 100-argument limit on functions. This error occurs when calling functions like json_build_object() with more than 100 arguments, or when passing too many parameters to RAISE statements in PL/pgSQL. Solutions include using array-based approaches or composite data types.
What causes "Too many arguments"?
Attempting to pass more than 100 arguments to a single function call (PostgreSQL hard limit) Using json_build_object() with too many key-value pairs (each column requires 2 arguments: key + value) Specifying too many parameters for RAISE statement placeholders in PL/pgSQL
Is the "Too many arguments" error serious?
Yes. This is a high-severity error that usually blocks work until it is fixed, but the steps above resolve it.

Official resources & further reading