📋

Description

This error indicates that PostgreSQL cannot uniquely identify which function to call based on the provided function name and argument types. It occurs when multiple overloaded functions exist, and the input arguments are not distinct enough to match a single function signature.

💬

Error Message

ambiguous function

🔍

Known Causes

4 known causes

⚠️

Overlapping Function Signatures

Multiple functions exist with the same name but with argument types that are implicitly convertible to each other, making the choice unclear for PostgreSQL.

⚠️

Missing Explicit Type Casts

Arguments provided to a function call might be of a generic or default type, requiring explicit casting to match a specific overloaded function signature.

⚠️

Untyped Literal Arguments

Using literal values (e.g., '10', 'true') without explicit type specification can lead to ambiguity if multiple functions could accept them after implicit casting.

⚠️

Conflicting Custom Functions

A user-defined function might have the same name and a similar signature to a built-in PostgreSQL function or another custom function in the search path.

🛠️

Solutions

3 solutions available

1. Explicitly Specify Function Argument Types easy

Provide explicit data types for function arguments to resolve ambiguity.

1

When calling a function, append the data type of each argument in parentheses after the function name. This clarifies which overloaded function version you intend to use.

SELECT my_function('some_string'::TEXT, 123::INTEGER);

2

If you have multiple overloaded functions with the same name but different argument types, ensure the types you provide in your call precisely match one of the defined signatures.

SELECT another_function(10::BIGINT, 'another_string'::VARCHAR);

2. Qualify Function Call with Schema Name easy

Prefix the function name with its schema to eliminate ambiguity if functions with the same name exist in different schemas.

1

If you have functions with the same name in different schemas (e.g., `public` and `custom_schema`), explicitly state the schema before the function name.

SELECT public.my_function('argument');

2

If the function is in a schema other than `public` or the one specified in your `search_path`, you must qualify it.

SELECT custom_schema.my_function(123);

3. Review and Refactor Overloaded Functions medium

Examine and potentially rename or redefine overloaded functions to reduce ambiguity.

1

Identify all functions with the same name using the `pg_proc` catalog. Pay close attention to their argument types and return types.

SELECT proname, pg_catalog.pg_get_function_identity_arguments(oid) FROM pg_catalog.pg_proc WHERE proname = 'my_function';

2

Consider renaming functions that have very similar signatures but could be made more distinct. For example, if you have `process_data(TEXT)` and `process_data(VARCHAR)`, and they perform conceptually different operations, consider renaming one.

-- Example of renaming:
ALTER FUNCTION my_function(TEXT) RENAME TO process_text_data;

3

Alternatively, if the overloading is unintentional or can be simplified, consider consolidating into a single function with more flexible argument handling (e.g., using `ANYELEMENT` or `VARIADIC` arrays) or creating distinct functions with clearly different names.

-- Example of using VARIADIC:
CREATE OR REPLACE FUNCTION process_multiple_values(VARIADIC values TEXT[]) RETURNS VOID AS $$
BEGIN
  FOREACH val IN ARRAY values LOOP
    RAISE NOTICE 'Processing: %', val;
  END LOOP;
END;
$$ LANGUAGE plpgsql;

🔗

Related Errors

5 related errors

PostgreSQL Error 42725: Ambiguous Function Call