OUT parameters in PostgreSQL

Introduction

OUT parameters let a database function return multiple values easily without using complex return types.

When you want a function to give back more than one result.

When you want to avoid creating custom types just to return multiple values.

When you want to write simple reusable functions that return several pieces of data.

When you want to get output values directly without using SELECT inside the function.

Syntax

PostgreSQL

CREATE FUNCTION function_name(IN param1 type, OUT out_param1 type, OUT out_param2 type) RETURNS record AS $$
BEGIN
  -- function body
  out_param1 := value1;
  out_param2 := value2;
END;
$$ LANGUAGE plpgsql;

OUT parameters are declared in the function signature and act like variables inside the function.

The function automatically returns a record containing all OUT parameters.

Examples

This function returns first and last name for a given user ID using OUT parameters.

PostgreSQL

CREATE FUNCTION get_full_name(IN user_id INT, OUT first_name TEXT, OUT last_name TEXT) RETURNS record AS $$
BEGIN
  SELECT fname, lname INTO first_name, last_name FROM users WHERE id = user_id;
END;
$$ LANGUAGE plpgsql;

This function returns the sum and product of two numbers using OUT parameters.

PostgreSQL

CREATE FUNCTION calculate_stats(IN a INT, IN b INT, OUT sum INT, OUT product INT) RETURNS record AS $$
BEGIN
  sum := a + b;
  product := a * b;
END;
$$ LANGUAGE plpgsql;

Sample Program

This example creates a users table, inserts two users, defines a function with OUT parameters to get full name by user ID, and calls it.

PostgreSQL

CREATE TABLE users (id INT, fname TEXT, lname TEXT);
INSERT INTO users VALUES (1, 'Alice', 'Smith'), (2, 'Bob', 'Jones');

CREATE FUNCTION get_full_name(IN user_id INT, OUT first_name TEXT, OUT last_name TEXT) RETURNS record AS $$
BEGIN
  SELECT fname, lname INTO first_name, last_name FROM users WHERE id = user_id;
END;
$$ LANGUAGE plpgsql;

-- Call the function
SELECT * FROM get_full_name(1);

Important Notes

You can call functions with OUT parameters using SELECT * FROM function_name(args);

If you have only OUT parameters and no IN parameters, you can call the function without arguments.

OUT parameters simplify returning multiple values without defining custom types.

Summary

OUT parameters let functions return multiple values easily.

They are declared in the function signature and act like output variables.

Use SELECT * FROM function_name(...) to get the results as columns.

Practice

1. What is the main purpose of OUT parameters in PostgreSQL functions?

easy

A. To define the function's return type as a single value

B. To declare input variables for the function

C. To create temporary tables inside the function

D. To allow a function to return multiple values as columns

Solution

1. Step 1: Understand OUT parameters role

   OUT parameters are used to return multiple values from a function as separate columns.

2. Step 2: Compare with other options

   Input variables are declared with IN, not OUT. Temporary tables and single return types are unrelated to OUT parameters.

3. Final Answer:

   To allow a function to return multiple values as columns -> Option D

4. Quick Check:

   OUT parameters = multiple return columns [OK]

Hint: OUT parameters return multiple columns from a function [OK]

Common Mistakes:

• Confusing OUT with IN parameters
• Thinking OUT creates tables
• Assuming OUT returns a single value

2. Which of the following is the correct syntax to declare an OUT parameter in a PostgreSQL function?

easy

A. CREATE FUNCTION f(a INT OUT) RETURNS VOID AS $$ ... $$ LANGUAGE plpgsql;

B. CREATE FUNCTION f(OUT a INT) RETURNS RECORD AS $$ ... $$ LANGUAGE plpgsql;

C. CREATE FUNCTION f(a INT) RETURNS OUT INT AS $$ ... $$ LANGUAGE plpgsql;

D. CREATE FUNCTION f(a INT) RETURNS TABLE(OUT a INT) AS $$ ... $$ LANGUAGE plpgsql;

Solution

1. Step 1: Check correct OUT parameter syntax

   OUT parameters are declared inside the parameter list as OUT name type. CREATE FUNCTION f(OUT a INT) RETURNS RECORD AS $$ ... $$ LANGUAGE plpgsql; matches this.

2. Step 2: Analyze other options

   CREATE FUNCTION f(a INT OUT) RETURNS VOID AS $$ ... $$ LANGUAGE plpgsql; wrongly places OUT after type. CREATE FUNCTION f(a INT) RETURNS OUT INT AS $$ ... $$ LANGUAGE plpgsql; misuses RETURNS OUT. CREATE FUNCTION f(a INT) RETURNS TABLE(OUT a INT) AS $$ ... $$ LANGUAGE plpgsql; misuses RETURNS TABLE with OUT inside parentheses.

3. Final Answer:

   CREATE FUNCTION f(OUT a INT) RETURNS RECORD AS $$ ... $$ LANGUAGE plpgsql; -> Option B

4. Quick Check:

   OUT parameters declared as 'OUT name type' [OK]

Hint: OUT parameters go inside parentheses before RETURNS [OK]

Common Mistakes:

• Placing OUT after the type
• Using RETURNS OUT instead of parameter list
• Confusing RETURNS TABLE syntax

3. Given the function:

CREATE FUNCTION get_person() RETURNS TABLE(id INT, name TEXT) AS $$
BEGIN
  RETURN QUERY SELECT 1, 'Alice';
END;
$$ LANGUAGE plpgsql;

What will be the output of SELECT * FROM get_person();?

medium

A. One row with columns id=1 and name='Alice'

B. No rows returned

C. Error: function does not have OUT parameters

D. One row with a single column containing a record

Solution

1. Step 1: Understand RETURNS TABLE behavior

   RETURNS TABLE defines OUT parameters implicitly, so the function returns rows with columns id and name.

2. Step 2: Analyze the RETURN QUERY statement

   The query returns one row with values (1, 'Alice'), so SELECT * FROM function returns that row.

3. Final Answer:

   One row with columns id=1 and name='Alice' -> Option A

4. Quick Check:

   RETURNS TABLE returns rows with named columns [OK]

Hint: RETURNS TABLE means function returns rows with named columns [OK]

Common Mistakes:

• Thinking RETURNS TABLE needs explicit OUT keyword
• Expecting no rows or error
• Assuming single column record output

4. Consider this function definition:

CREATE FUNCTION calc_sum(a INT, b INT, OUT result INT) AS $$
BEGIN
  result := a + b;
END;
$$ LANGUAGE plpgsql;

Which of the following calls will cause an error?

medium

A. SELECT * FROM calc_sum(2, 3);

B. SELECT calc_sum(2, 3);

C. CALL calc_sum(2, 3, result_var);

D. SELECT result FROM calc_sum(2, 3);

Solution

1. Step 1: Understand how OUT parameters affect function call

   Functions with OUT parameters return a record, so SELECT * FROM calc_sum(2, 3); works and returns result column.

2. Step 2: Analyze each call

   SELECT calc_sum(2, 3); returns a record but as a single column, valid. SELECT result FROM calc_sum(2, 3); tries to select a column named 'result' directly from function call without FROM, which is invalid syntax. CALL calc_sum(2, 3, result_var); is invalid syntax for CALL with OUT parameters and will cause an error.

3. Final Answer:

   CALL calc_sum(2, 3, result_var); -> Option C

4. Quick Check:

   CALL with OUT parameters requires different syntax [OK]

Hint: Use SELECT * FROM function() with OUT params, not SELECT column directly or CALL with extra params [OK]

Common Mistakes:

• Selecting OUT column without FROM clause
• Using CALL incorrectly with OUT parameters
• Assuming function returns scalar value

5. You want to create a function that returns both the length and uppercase version of a text input using OUT parameters. Which of the following function definitions correctly achieves this?

hard

A. CREATE FUNCTION text_info(input TEXT, OUT len INT, OUT upper TEXT) AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql;

B. CREATE FUNCTION text_info(input TEXT) RETURNS TABLE(len INT, upper TEXT) AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql;

C. CREATE FUNCTION text_info(input TEXT, OUT len INT, OUT upper TEXT) RETURNS RECORD AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql;

D. CREATE FUNCTION text_info(input TEXT) RETURNS RECORD AS $$ BEGIN RETURN QUERY SELECT length(input), upper(input); END; $$ LANGUAGE plpgsql;

Solution

1. Step 1: Check OUT parameter declaration and assignment

   CREATE FUNCTION text_info(input TEXT, OUT len INT, OUT upper TEXT) AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql; declares OUT parameters in the signature and assigns values inside the function body, which is correct.

2. Step 2: Compare other options

   CREATE FUNCTION text_info(input TEXT) RETURNS TABLE(len INT, upper TEXT) AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql; uses RETURNS TABLE but does not assign values properly. CREATE FUNCTION text_info(input TEXT, OUT len INT, OUT upper TEXT) RETURNS RECORD AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql; mixes OUT parameters with RETURNS RECORD incorrectly. CREATE FUNCTION text_info(input TEXT) RETURNS RECORD AS $$ BEGIN RETURN QUERY SELECT length(input), upper(input); END; $$ LANGUAGE plpgsql; returns a record but does not use OUT parameters as requested.

3. Final Answer:

   CREATE FUNCTION text_info(input TEXT, OUT len INT, OUT upper TEXT) AS $$ BEGIN len := length(input); upper := upper(input); END; $$ LANGUAGE plpgsql; -> Option A

4. Quick Check:

   OUT params declared and assigned inside function [OK]

Hint: Declare OUT params in signature and assign inside function [OK]

Common Mistakes:

• Mixing RETURNS TABLE with OUT params incorrectly
• Not assigning OUT parameters inside function
• Using RETURNS RECORD without OUT params