How to diagnose and resolve the dynamic_result_sets_returned error message in postgres

The dynamic_result_sets_returned error message in PostgreSQL is related to a specific SQLSTATE error code which indicates that a stored procedure attempted to return more result sets than were expected. This can occur when using a language like PL/pgSQL for writing stored procedures, which are expected to return a defined number of result sets, and the actual number of result sets returned does not match this expectation.

To diagnose and resolve this error, follow these steps:

  1. Review the Stored Procedure Code: Check the stored procedure that is causing the error. Look for cursors that are opened with the RETURN QUERY command or any result set being returned by the procedure. Ensure that the number of result sets the procedure is trying to return matches what the calling context expects.
  2. Check the Procedure’s Documentation: Make sure that you understand the intended behavior of the procedure. Sometimes the documentation will specify the number of result sets that should be returned.
  3. Modify the Procedure if Necessary: If the procedure is returning more result sets than it should, modify the procedure to ensure that it only returns the expected number of result sets. This might involve removing or consolidating RETURN QUERY statements or adjusting the logic that determines when these statements are executed.
  4. Check Client Application Expectations: If the stored procedure is being called from an application, ensure that the application is equipped to handle the number of result sets that the procedure returns. The application code might need to be adjusted to process the correct number of result sets.
  5. Testing: After making changes, thoroughly test the stored procedure to ensure that it now behaves as expected and that the dynamic_result_sets_returned error no longer occurs.
  6. Consult PostgreSQL Documentation: For more details on error handling and the RAISE statement in PL/pgSQL, you can refer to the official PostgreSQL documentation.

If after these steps the issue persists, consider seeking help from the PostgreSQL community or checking for specific guidance related to the dynamic_result_sets_returned error code in PostgreSQL resources or forums.


Let’s consider an example of a PL/pgSQL function in PostgreSQL that might trigger the dynamic_result_sets_returned error if it is not handled properly.

Imagine we have a function designed to return two separate result sets based on two different queries:

CREATE OR REPLACE FUNCTION get_two_result_sets()
RETURNS SETOF refcursor AS $$
    ref1 refcursor;
    ref2 refcursor;
    -- Open the first cursor for the first result set
    OPEN ref1 FOR SELECT * FROM table1 WHERE condition1;
    RETURN NEXT ref1;

    -- Open the second cursor for the second result set
    OPEN ref2 FOR SELECT * FROM table2 WHERE condition2;
    RETURN NEXT ref2;
$$ LANGUAGE plpgsql;

In the above function, we are attempting to return two refcursors, each pointing to a different result set. When this function is executed, it should return two separate cursors that the client application can then fetch from.

However, if the calling application is expecting only one result set and the function returns two, it might raise the dynamic_result_sets_returned error, because the number of result sets does not match the expectation.

To resolve this, you would need to adjust either the function or the application so that the expectations match the actual behavior. If the application should only handle one result set, you could modify the function to return only one cursor:

CREATE OR REPLACE FUNCTION get_single_result_set()
RETURNS refcursor AS $$
    ref1 refcursor;
    -- Open the cursor for the desired result set
    OPEN ref1 FOR SELECT * FROM table1 WHERE condition1;
    RETURN ref1;
$$ LANGUAGE plpgsql;

Now, when this function is called, it will return only one result set, which should be in line with what the application expects, and the error should no longer occur.

Always ensure that the client application calling the function knows exactly how many result sets to expect and is coded to handle them appropriately.

Leave a Comment