Common Table Expressions (CTEs) in Snowflake - Commands & Configuration

Introduction

Sometimes you need to break down a complex query into smaller parts to make it easier to read and manage. Common Table Expressions, or CTEs, let you do this by creating temporary named result sets that you can use within your main query.

When you want to organize a long query into smaller, understandable pieces.

When you need to reuse the same subquery multiple times in a larger query.

When you want to improve the readability of your SQL code for yourself or others.

When you want to perform step-by-step data transformations before the final output.

When you want to avoid repeating complex joins or calculations in your query.

Commands

This command creates a CTE named recent_orders that selects orders after January 1, 2024. Then it queries this CTE to count how many recent orders each customer made, sorting customers by their order count.

Terminal

WITH recent_orders AS (
  SELECT order_id, customer_id, order_date
  FROM orders
  WHERE order_date > '2024-01-01'
)
SELECT customer_id, COUNT(order_id) AS order_count
FROM recent_orders
GROUP BY customer_id
ORDER BY order_count DESC;

Expected Output

CUSTOMER_ID | ORDER_COUNT

------------|------------

123         | 5

456         | 3

789         | 2

This command shows how to use multiple CTEs. The first CTE filters recent orders, and the second counts orders per customer. The final query selects customers with more than two orders.

Terminal

WITH recent_orders AS (
  SELECT order_id, customer_id, order_date
  FROM orders
  WHERE order_date > '2024-01-01'
),
customer_totals AS (
  SELECT customer_id, COUNT(order_id) AS total_orders
  FROM recent_orders
  GROUP BY customer_id
)
SELECT * FROM customer_totals WHERE total_orders > 2;

Expected Output

CUSTOMER_ID | TOTAL_ORDERS

------------|-------------

123         | 5

456         | 3

Key Concept

If you remember nothing else from this pattern, remember: CTEs let you name and reuse parts of your query to make complex SQL easier to read and maintain.

Common Mistakes

Not placing the WITH clause at the very start of the query.

Snowflake requires the CTE to be defined before the main SELECT statement; otherwise, it causes a syntax error.

Always start your query with the WITH clause when using CTEs.

Trying to reference a CTE outside the query where it is defined.

CTEs exist only for the duration of the query they are part of and cannot be reused elsewhere.

Use the CTE only within the same query or define a view if reuse is needed across queries.

Using semicolons before the WITH clause in multi-statement scripts.

A semicolon before WITH can end the previous statement and cause the CTE to be treated as a new statement, leading to errors.

Do not put a semicolon before the WITH clause; place it only at the end of the entire query.

Summary

Use WITH to define temporary named result sets called CTEs at the start of your query.

CTEs help break complex queries into smaller, readable parts and can be chained together.

Always write the WITH clause before the main SELECT and use CTEs only within the same query.

Practice

1. What is the main purpose of using a WITH clause in Snowflake SQL?

easy

A. To set session variables

B. To permanently store data in a new table

C. To create a user-defined function

D. To define a temporary named result set for use in a query

Solution

1. Step 1: Understand the role of the WITH clause

   The WITH clause defines a Common Table Expression (CTE), which is a temporary named result set used within a query.

2. Step 2: Differentiate from other SQL features

   Unlike permanent tables or functions, CTEs exist only during query execution and help organize complex queries.

3. Final Answer:

   To define a temporary named result set for use in a query -> Option D

4. Quick Check:

   WITH clause = temporary named result set [OK]

Hint: WITH means temporary named query part [OK]

Common Mistakes:

• Thinking WITH creates permanent tables
• Confusing WITH with functions or variables
• Assuming WITH changes session settings

2. Which of the following is the correct syntax to start a CTE in Snowflake?

easy

A. CREATE CTE cte_name AS (SELECT * FROM table);

B. DEFINE cte_name SELECT * FROM table;

C. WITH cte_name AS (SELECT * FROM table)

D. BEGIN CTE cte_name SELECT * FROM table;

Solution

1. Step 1: Recall the standard CTE syntax

   In Snowflake, a CTE starts with the keyword WITH followed by the CTE name and AS, then the query in parentheses.

2. Step 2: Compare options to syntax

   WITH cte_name AS (SELECT * FROM table) matches this pattern exactly: WITH cte_name AS (SELECT * FROM table)

3. Final Answer:

   WITH cte_name AS (SELECT * FROM table) -> Option C

4. Quick Check:

   CTE syntax starts with WITH [OK]

Hint: CTE always starts with WITH keyword [OK]

Common Mistakes:

• Using CREATE instead of WITH
• Omitting AS keyword
• Using BEGIN or DEFINE which are invalid here

3. Given the query:

WITH cte AS (SELECT 1 AS num UNION ALL SELECT 2) SELECT SUM(num) FROM cte;

What is the output of this query?

medium

A. 3

B. 2

C. 1

D. Error

Solution

1. Step 1: Understand the CTE content

   The CTE named 'cte' selects two rows with values 1 and 2 under the column 'num'.

2. Step 2: Calculate the SUM of 'num'

   The main query sums the values 1 and 2, resulting in 3.

3. Final Answer:

   3 -> Option A

4. Quick Check:

   1 + 2 = 3 [OK]

Hint: Sum values inside CTE then add [OK]

Common Mistakes:

• Thinking UNION ALL removes duplicates
• Confusing SUM with COUNT
• Expecting syntax error due to CTE

4. Identify the error in the following Snowflake query using a CTE:

WITH cte AS SELECT * FROM employees SELECT * FROM cte;

medium

A. Missing parentheses around the CTE query

B. CTE name cannot be 'cte'

C. CTE cannot be used in the same query

D. Missing AS keyword before SELECT in CTE definition

Solution

1. Step 1: Review CTE syntax requirements

   A CTE query must be enclosed in parentheses after the AS keyword.

2. Step 2: Check the given query

   The query lacks parentheses around the SELECT statement in the CTE definition.

3. Final Answer:

   Missing parentheses around the CTE query -> Option A

4. Quick Check:

   CTE query must be in parentheses [OK]

Hint: CTE query always inside parentheses [OK]

Common Mistakes:

• Omitting parentheses around CTE query
• Thinking CTE names are restricted
• Believing CTEs can't be reused in same query

5. You want to calculate the average salary per department using a CTE named dept_salaries that selects employee salaries and departments. Which query correctly uses the CTE to get the average salary per department?

hard

A. WITH dept_salaries AS SELECT department, salary FROM employees SELECT department, AVG(salary) FROM dept_salaries GROUP BY department;

B. WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT department, AVG(salary) FROM dept_salaries GROUP BY department;

C. WITH dept_salaries (department, salary) AS (SELECT department, salary FROM employees) SELECT AVG(salary) FROM dept_salaries;

D. WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT AVG(salary) FROM employees GROUP BY department;

Solution

1. Step 1: Verify correct CTE syntax and usage

   WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT department, AVG(salary) FROM dept_salaries GROUP BY department; correctly defines the CTE with parentheses and AS, then uses it to select department and average salary grouped by department.

2. Step 2: Check aggregation and grouping

   WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT department, AVG(salary) FROM dept_salaries GROUP BY department; groups by department and calculates AVG(salary) from the CTE, which is the intended calculation.

3. Final Answer:

   WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT department, AVG(salary) FROM dept_salaries GROUP BY department; -> Option B

4. Quick Check:

   CTE with correct syntax and grouping = WITH dept_salaries AS (SELECT department, salary FROM employees) SELECT department, AVG(salary) FROM dept_salaries GROUP BY department; [OK]

Hint: Use WITH ... AS (...) then GROUP BY correctly [OK]

Common Mistakes:

• Omitting parentheses in CTE definition
• Not grouping by department when aggregating
• Using employees table instead of CTE in main query