How to diagnose and fix the 22P01 floating_point_exception error code in Postgres.

The 22P01 error code in PostgreSQL, described as floating_point_exception, occurs when an invalid floating-point operation is encountered. This might happen during arithmetic calculations that produce a result that is not a valid floating-point number, such as division by zero, overflow, underflow, or operations on NaN (not a number) values (PostgreSQL Error Codes).

To diagnose and fix this error, you should:

  1. Check the error message for details about the operation that caused the issue. PostgreSQL will typically indicate the problematic part of the SQL statement.
  2. Identify the arithmetic operation that is causing the floating-point exception.
  3. Modify the SQL statement to avoid the invalid operation. This could involve adding checks to prevent division by zero, adjusting the inputs to avoid overflow or underflow, or handling NaN values appropriately.

Here are some examples and sample code to illustrate the process:

Example 1: Division by zero

Suppose you have the following SQL statement that divides two numbers:


SELECT 1.0 / 0.0;

This statement will cause a floating_point_exception because division by zero is undefined.

To fix this, you should ensure that the divisor is not zero:


SELECT 1.0 / NULLIF(0.0, 0.0); -- Returns NULL instead of causing an error

The NULLIF function returns NULL if the second argument equals the first one, thus avoiding the division by zero.

Example 2: Overflow

If you perform an operation that results in a value that exceeds the range of the floating-point type, you’ll encounter the 22P01 error.


SELECT POWER(10.0, 1000);

This might cause an overflow due to the large result.

To fix this, you could adjust the inputs to stay within the range of the floating-point type:


SELECT POWER(10.0, 10); -- A smaller exponent to avoid overflow

Example 3: Operations on NaN values

Performing certain operations on NaN values can also result in a floating_point_exception.


SELECT 0.0 / 0.0; -- Produces NaN

To fix this, you should ensure that the operation does not produce a NaN:


SELECT 1.0 / NULLIF(0.0, 0.0); -- Avoids NaN by using NULLIF as shown before

When dealing with floating-point numbers, it’s crucial to understand the limitations and behavior of floating-point arithmetic. Adding appropriate checks and handling edge cases in your SQL statements can help prevent the 22P01 error code.

Leave a Comment