Postgres functions basics in Supabase - Step-by-Step Execution

Process Flow - Postgres functions basics

Start: Call function

↓

Enter function body

↓

Execute SQL statements

↓

Return result

↓

End function execution

When you call a Postgres function, it runs the SQL inside it and then returns a result.

Execution Sample

Supabase

CREATE FUNCTION add_numbers(a INT, b INT) RETURNS INT
LANGUAGE plpgsql AS $$
BEGIN
  RETURN a + b;
END;
$$;

This function adds two numbers and returns the sum.

Process Table

Step	Action	Input Values	Operation	Result
1	Function called	a=3, b=5	Start execution	No output yet
2	Execute RETURN	a=3, b=5	Calculate a + b	8
3	Function ends	a=3, b=5	Return result	8

💡 Function returns the sum 8 and execution stops

Status Tracker

Variable	Start	After Step 1	After Step 2	Final
a	undefined	3	3	3
b	undefined	5	5	5
result	undefined	undefined	8	8

Key Moments - 2 Insights

Why do we use RETURN inside the function?

RETURN sends back the final answer from the function, as shown in step 2 of the execution_table.

What happens if we call the function with different numbers?

The function uses the new inputs each time, like variables a and b change in the variable_tracker.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 2?

A 8

B 3

C 5

D No output yet

💡 Hint

Check the 'Result' column in row for step 2 in execution_table

At which step does the function return the result?

A Step 1

B Step 3

C Step 2

D Never

💡 Hint

Look at the 'Action' and 'Operation' columns in execution_table for when the function ends

If we call add_numbers(10, 20), what will be the result?

A 20

B 10

C 30

D Function error

💡 Hint

Refer to variable_tracker and how a + b is calculated in execution_table

Concept Snapshot

Postgres functions run SQL code inside them.
Use CREATE FUNCTION with parameters and RETURN type.
Inside, use RETURN to send back a result.
Call function with inputs to get outputs.
Functions help reuse SQL logic easily.

Full Transcript

A Postgres function is a reusable block of SQL code that takes inputs, runs commands, and returns a result. When you call the function, it starts execution, uses the input values, runs the SQL inside, and then returns the output with RETURN. For example, a function add_numbers takes two numbers, adds them, and returns the sum. The execution table shows each step: calling the function, calculating the sum, and returning it. Variables a and b hold inputs, and result holds the output. Beginners often wonder why RETURN is needed: it sends the final answer back. Also, each function call can use different inputs, producing different outputs. This makes functions powerful for repeating tasks in databases.

Practice

1. What is the main purpose of a Postgres function in Supabase?

easy

A. To store reusable code inside the database

B. To create user interface elements

C. To manage server hardware

D. To backup the entire database automatically

Solution

1. Step 1: Understand what Postgres functions do

   Postgres functions hold code that can be run repeatedly inside the database.

2. Step 2: Compare options with this purpose

   Only To store reusable code inside the database matches this description; others relate to UI, hardware, or backups, which are unrelated.

3. Final Answer:

   To store reusable code inside the database -> Option A

4. Quick Check:

   Postgres functions = reusable database code [OK]

Hint: Functions store code to reuse inside the database [OK]

Common Mistakes:

• Confusing functions with UI components
• Thinking functions manage hardware
• Assuming functions handle backups automatically

2. Which of the following is the correct way to start defining a simple Postgres function?

easy

A. FUNCTION CREATE function_name() RETURNS type AS BEGIN ... END;

B. MAKE FUNCTION function_name RETURNS type { ... }

C. CREATE FUNCTION function_name() RETURNS type AS $$ BEGIN ... END; $$ LANGUAGE plpgsql;

D. DEFINE FUNCTION function_name() RETURNS type BEGIN ... END;

Solution

1. Step 1: Recall Postgres function syntax

   The correct syntax starts with CREATE FUNCTION, includes RETURNS, and uses $$ to wrap the body.

2. Step 2: Match options to syntax

   Only CREATE FUNCTION function_name() RETURNS type AS $$ BEGIN ... END; $$ LANGUAGE plpgsql; matches the exact syntax; others use incorrect keywords or order.

3. Final Answer:

   CREATE FUNCTION function_name() RETURNS type AS $$ BEGIN ... END; $$ LANGUAGE plpgsql; -> Option C

4. Quick Check:

   CREATE FUNCTION + RETURNS + $$ ... $$ = correct syntax [OK]

Hint: Postgres functions start with CREATE FUNCTION and use $$ for body [OK]

Common Mistakes:

• Using MAKE or DEFINE instead of CREATE
• Omitting LANGUAGE plpgsql
• Not wrapping function body with $$

3. Given this function, what will SELECT add_two_numbers(3, 4); return?

CREATE FUNCTION add_two_numbers(a integer, b integer) RETURNS integer AS $$ BEGIN RETURN a + b; END; $$ LANGUAGE plpgsql;

medium

A. NULL

B. 34

C. Error: function not found

D. 7

Solution

1. Step 1: Understand function behavior

   The function adds two integers a and b and returns their sum.

2. Step 2: Calculate the result for inputs 3 and 4

   3 + 4 equals 7, so the function returns 7.

3. Final Answer:

   7 -> Option D

4. Quick Check:

   3 + 4 = 7 [OK]

Hint: Function adds inputs; 3 + 4 = 7 [OK]

Common Mistakes:

• Concatenating numbers as strings (34)
• Assuming function is missing or returns NULL
• Confusing syntax errors with output

4. Identify the error in this Postgres function:

CREATE FUNCTION multiply_by_two(x integer) RETURNS integer AS $$ BEGIN RETURN x * 2 END; $$ LANGUAGE plpgsql;

medium

A. Missing semicolon after RETURN statement

B. Incorrect function name

C. Wrong language specified

D. No error, function is correct

Solution

1. Step 1: Check function syntax carefully

   In PL/pgSQL, statements inside BEGIN...END must end with semicolons.

2. Step 2: Locate missing semicolon

   The RETURN statement lacks a semicolon at the end, causing a syntax error.

3. Final Answer:

   Missing semicolon after RETURN statement -> Option A

4. Quick Check:

   Statements inside BEGIN...END need semicolons [OK]

Hint: Check for missing semicolons inside BEGIN...END [OK]

Common Mistakes:

• Forgetting semicolon after RETURN
• Assuming function name or language is wrong
• Thinking function is correct without semicolon

5. You want to create a Postgres function that returns the length of a text input only if it is not empty; otherwise, it returns NULL. Which function definition correctly implements this?

hard

A. CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN RETURN length(input); END; $$ LANGUAGE plpgsql;

B. CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input = '' THEN RETURN NULL; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql;

C. CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input IS NULL THEN RETURN 0; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql;

D. CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input = NULL THEN RETURN NULL; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql;

Solution

1. Step 1: Understand the condition to check empty string

   The function must check if input equals empty string ('') and return NULL in that case.

2. Step 2: Evaluate each option's condition

   CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input = '' THEN RETURN NULL; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql; correctly checks input = '' and returns NULL; CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN RETURN length(input); END; $$ LANGUAGE plpgsql; always returns length; CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input IS NULL THEN RETURN 0; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql; checks NULL instead of empty; CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input = NULL THEN RETURN NULL; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql; uses incorrect NULL comparison.

3. Final Answer:

   CREATE FUNCTION text_length_if_not_empty(input text) RETURNS integer AS $$ BEGIN IF input = '' THEN RETURN NULL; ELSE RETURN length(input); END IF; END; $$ LANGUAGE plpgsql; -> Option B

4. Quick Check:

   Check empty string with = '' and return NULL [OK]

Hint: Use IF input = '' THEN RETURN NULL; ELSE RETURN length(input); [OK]

Common Mistakes:

• Using input = NULL instead of IS NULL
• Not checking for empty string
• Returning 0 instead of NULL for empty input