GENERATED columns (stored and virtual) in PostgreSQL - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

Output of a stored generated column calculation

Consider the following table definition and insert statement in PostgreSQL:

CREATE TABLE sales (
  price numeric,
  quantity int,
  total numeric GENERATED ALWAYS AS (price * quantity) STORED
);

INSERT INTO sales (price, quantity) VALUES (10, 3);

What will be the output of the query SELECT total FROM sales;?

PostgreSQL

CREATE TABLE sales (
  price numeric,
  quantity int,
  total numeric GENERATED ALWAYS AS (price * quantity) STORED
);

INSERT INTO sales (price, quantity) VALUES (10, 3);

SELECT total FROM sales;

A 30

B NULL

C 13

D Syntax error

💡 Hint

Stored generated columns calculate and store the value automatically based on the expression.

The stored generated column 'total' is calculated as price * quantity, so 10 * 3 = 30 is stored and returned.

📝 Syntax

intermediate

Correct syntax for generated column definition

Which of the following CREATE TABLE statements correctly defines a generated column in PostgreSQL?

A CREATE TABLE items (a int, b int GENERATED ALWAYS AS (a * 2) STORED);

B CREATE TABLE items (a int, b int GENERATED ALWAYS AS (a * 2) VIRTUAL);

C CREATE TABLE items (a int, b int AS (a * 2) VIRTUAL);

D CREATE TABLE items (a int, b int GENERATED ALWAYS AS (a * 2));

💡 Hint

PostgreSQL supports only STORED generated columns, not VIRTUAL.

PostgreSQL currently supports only STORED generated columns. The option with VIRTUAL keyword causes syntax error.

🧠 Conceptual

advanced

Difference between stored and virtual generated columns

Which statement correctly describes the difference between stored and virtual generated columns in databases?

A Stored columns compute values on query time; virtual columns store values physically.

B Stored columns store computed values physically; virtual columns compute values on query time without storing.

C Both stored and virtual columns store computed values physically but differ in update speed.

D Virtual columns are deprecated and replaced by stored columns in all databases.

💡 Hint

Think about when the value is calculated and if it is saved on disk.

Stored generated columns save the computed value physically in the table, while virtual columns compute the value on the fly when queried without storing it.

🔧 Debug

advanced

Why does this generated column cause an error?

Given the table definition:

CREATE TABLE orders (
  unit_price numeric,
  quantity int,
  total numeric NOT NULL GENERATED ALWAYS AS (unit_price * quantity) STORED
);

INSERT INTO orders (unit_price, quantity) VALUES (5, NULL);

Why does the insert statement fail?

PostgreSQL

CREATE TABLE orders (
  unit_price numeric,
  quantity int,
  total numeric NOT NULL GENERATED ALWAYS AS (unit_price * quantity) STORED
);

INSERT INTO orders (unit_price, quantity) VALUES (5, NULL);

A Because generated columns cannot reference nullable columns.

B Because the table definition is missing a primary key.

C Because the multiplication operator is invalid for numeric and NULL types.

D Because quantity is NULL, the generated column expression results in NULL which is not allowed for stored columns.

💡 Hint

Consider how NULL values affect expressions in generated columns.

The expression unit_price * quantity evaluates to NULL when quantity is NULL. Stored generated columns cannot store NULL if the column is defined NOT NULL or if the database disallows it.

❓ optimization

expert

Optimizing queries using stored generated columns

You have a table with a stored generated column that calculates total_price as unit_price * quantity. Which query will generally perform better in PostgreSQL?

A SELECT unit_price, quantity FROM sales WHERE unit_price * quantity > 100;

B SELECT unit_price * quantity AS total_price FROM sales WHERE unit_price * quantity > 100;

C SELECT total_price FROM sales WHERE total_price > 100;

D SELECT total_price FROM sales WHERE unit_price * quantity > 100;

💡 Hint

Think about how stored generated columns can be indexed and reused.

Using the stored generated column in the WHERE clause allows PostgreSQL to use indexes on that column, improving performance. Calculating the expression repeatedly in the query is less efficient.