Knowledge Guide
Home › Databases › SQL Practice Problems

Evaluate Boolean Expression

Problem

Table Variables:

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| name          | varchar |
| value         | int     |
+---------------+---------+
In the `Variables` table, `name` is the primary key.
This table contains the stored variables and their values.

Table Expressions:

+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| left_operand  | varchar |
| operator      | enum    |
| right_operand | varchar |
+---------------+---------+
In the `Expressions` table, (left_operand, operator, right_operand) is the primary key.
This table contains a boolean expression that should be evaluated.
operator is an enum that takes one of the values ('<', '>', '=')
The values of left_operand and right_operand are guaranteed to be in the Variables table.

Problem Definition

Evaluate the boolean expressions in the Expressions table.

Return the result table in the any order.

Example

Image
Image

Output

Image
Image

Try It Yourself

java
-- TODO: Write your user queries here

Solution

To evaluate the boolean expressions in the Expressions table based on the values of variables in the Variables table, we need to systematically process and compare the values of the operands using the specified operators. This involves joining the tables to retrieve the necessary values and then applying conditional logic to determine the outcome of each expression.

  1. Join Expressions with Variables to Retrieve Operand Values:

    • Left Operand: Associate each expression's left_operand with its corresponding value from the Variables table.
    • Right Operand: Similarly, associate each expression's right_operand with its corresponding value from the Variables table.

  2. Evaluate Each Boolean Expression:

    • Use a CASE statement to compare the retrieved operand values based on the specified operator (<, >, =).
    • Assign 'true' if the condition is met; otherwise, assign 'false'.

SQL Query

SELECT e1.left_operand,
       e1.operator,
       e1.right_operand,
       CASE
           WHEN e1.operator = '<' AND v1.value < v2.value THEN 'true'
           WHEN e1.operator = '>' AND v1.value > v2.value THEN 'true'
           WHEN e1.operator = '=' AND v1.value = v2.value THEN 'true'
           ELSE 'false'
       END AS value
FROM   Expressions e1
       JOIN Variables v1 ON e1.left_operand = v1.name
       JOIN Variables v2 ON e1.right_operand = v2.name;

Step-by-Step Approach

Step 1: Join Expressions with Variables to Retrieve Left Operand Values

Associate each expression's left_operand with its corresponding value from the Variables table. This allows us to access the numerical value needed for evaluation.

SQL Query:

SELECT e1.left_operand,
       e1.operator,
       e1.right_operand,
       v1.value AS left_value
FROM   Expressions e1
       JOIN Variables v1 ON e1.left_operand = v1.name;

Explanation:

Output After Step 1:

+--------------+----------+---------------+------------+
| left_operand | operator | right_operand | left_value |
+--------------+----------+---------------+------------+
| x            | >        | y             | 66         |
| x            | <        | y             | 66         |
| x            | =        | y             | 66         |
| y            | >        | x             | 77         |
| y            | <        | x             | 77         |
| x            | =        | x             | 66         |
+--------------+----------+---------------+------------+

Step 2: Join Expressions with Variables to Retrieve Right Operand Values

Associate each expression's right_operand with its corresponding value from the Variables table. This complements the left_value obtained in Step 1, enabling complete evaluation of the expression.

SQL Query:

SELECT e1.left_operand,
       e1.operator,
       e1.right_operand,
       v1.value AS left_value,
       v2.value AS right_value
FROM   Expressions e1
       JOIN Variables v1 ON e1.left_operand = v1.name
       JOIN Variables v2 ON e1.right_operand = v2.name;

Explanation:

Output After Step 2:

+--------------+----------+---------------+------------+-------------+
| left_operand | operator | right_operand | left_value | right_value |
+--------------+----------+---------------+------------+-------------+
| x            | >        | y             | 66         | 77          |
| x            | <        | y             | 66         | 77          |
| x            | =        | y             | 66         | 77          |
| y            | >        | x             | 77         | 66          |
| y            | <        | x             | 77         | 66          |
| x            | =        | x             | 66         | 66          |
+--------------+----------+---------------+------------+-------------+

Step 3: Evaluate Each Boolean Expression Using CASE Statement

Determine whether each expression evaluates to 'true' or 'false' based on the comparison of left_value and right_value using the specified operator.

SQL Query:

SELECT e1.left_operand,
       e1.operator,
       e1.right_operand,
       v1.value AS left_value,
       v2.value AS right_value,
       CASE
           WHEN e1.operator = '<' AND v1.value < v2.value THEN 'true'
           WHEN e1.operator = '>' AND v1.value > v2.value THEN 'true'
           WHEN e1.operator = '=' AND v1.value = v2.value THEN 'true'
           ELSE 'false'
       END AS value
FROM   Expressions e1
       JOIN Variables v1 ON e1.left_operand = v1.name
       JOIN Variables v2 ON e1.right_operand = v2.name;

Explanation:

Output After Step 3:

+--------------+----------+---------------+------------+-------------+--------+
| left_operand | operator | right_operand | left_value | right_value | value  |
+--------------+----------+---------------+------------+-------------+--------+
| x            | >        | y             | 66         | 77          | false  |
| x            | <        | y             | 66         | 77          | true   |
| x            | =        | y             | 66         | 77          | false  |
| y            | >        | x             | 77         | 66          | true   |
| y            | <        | x             | 77         | 66          | false  |
| x            | =        | x             | 66         | 66          | true   |
+--------------+----------+---------------+------------+-------------+--------+

Final Output:

+--------------+----------+---------------+--------+
| left_operand | operator | right_operand | value  |
+--------------+----------+---------------+--------+
| x            | >        | y             | false  |
| x            | <        | y             | true   |
| x            | =        | y             | false  |
| y            | >        | x             | true   |
| y            | <        | x             | false  |
| x            | =        | x             | true   |
+--------------+----------+---------------+--------+
🤖 Don't fully get this? Learn it with Claude

Stuck on Evaluate Boolean Expression? Open Claude, copy a block below, and it'll teach you this exact concept — visually and interactively.

🎨 Explain it visually

Build the mental picture, not memorization.

I just read a lesson on **Evaluate Boolean Expression** (Databases) and want to truly understand it. Explain Evaluate Boolean Expression from first principles using ONE vivid real-world analogy and a visual mental model — draw it as ASCII art or a clear step-by-step diagram — with a concrete example using real numbers. Then ask me one question to check I got the mental picture, and wait for my reply. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🤔 Walk me through it (interactive)

Socratic — adapts to where you're stuck.

Teach me **Evaluate Boolean Expression** interactively. Ask me ONE guiding question at a time, wait for my answer, and adapt to my confusion — build the idea with me step by step instead of explaining it all at once. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🧪 Quiz me & fix my gaps

Active recall exposes what you missed.

Quiz me on **Evaluate Boolean Expression** with 5 questions, easy to tricky, ONE at a time. Tell me if each answer is right; at the end, explain clearly what I got wrong and why. If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.
🧠 Make it stick

Intuition + hook + flashcards for long-term memory.

Help me remember **Evaluate Boolean Expression** for the long term: give the one-sentence intuition, a memorable hook/mnemonic, a tiny worked example, and 3 active-recall flashcards (Q -> A). If you're unsure or a claim isn't standard, say so and reason from first principles instead of guessing.

📝 My notes

← Running Total for Different GenderActive Users →