PostgreSQL Arithmetic Operators Quiz: Test Your SQL Skills

Progress

True / False

In PostgreSQL, the addition operator (+) can be used to add two numeric values.

True False

The addition operator (+) in PostgreSQL is used to add two numeric values.

True / False

PostgreSQL does not support the subtraction operator (-) for numeric data types.

True False

PostgreSQL supports the subtraction operator (-) for numeric data types, allowing the subtraction of one numeric value from another.

True / False

In PostgreSQL, the multiplication operator (*) can be used to multiply two numeric values.

True False

The multiplication operator (*) in PostgreSQL is used to multiply two numeric values.

True / False

PostgreSQL supports the division operator (/) for numeric data types, and it will return an integer result if both operands are integers.

True False

PostgreSQL's division operator (/) for numeric data types will return a floating-point result even if both operands are integers.

True / False

In PostgreSQL, the modulus operator (%) returns the remainder of a division operation.

True False

The modulus operator (%) in PostgreSQL returns the remainder of a division operation.

True / False

PostgreSQL allows the use of parentheses to change the order of arithmetic operations in an expression

True False

Parentheses can be used in PostgreSQL to change the order of operations in an arithmetic expression, ensuring certain operations are performed first.

True / False

In PostgreSQL, arithmetic operations on numeric types can result in overflow errors if the result exceeds the range of the numeric type.

True False

Arithmetic operations on numeric types in PostgreSQL can result in overflow errors if the result exceeds the defined range of the numeric type.

True / False

PostgreSQL automatically converts data types to avoid errors in arithmetic expressions.

True False

PostgreSQL does not automatically convert data types in all cases to avoid errors. Explicit type casting might be necessary to ensure compatibility in arithmetic expressions.

True / False

In PostgreSQL, performing arithmetic operations on interval data types is not supported.

True False

PostgreSQL supports arithmetic operations on interval data types, allowing addition and subtraction of intervals.

Q10

True / False

In PostgreSQL, the power() function can be used to perform exponentiation, and the result will be of type numeric.

True False

The power() function in PostgreSQL performs exponentiation and returns a result of type numeric.

Q11

Single Choice

What is the result of the following PostgreSQL query?

SQL Code

SELECT 10 + 5;

105 15 510

The + operator adds two numbers. In this case, 10 + 5 results in 15.

Q12

Single Choice

What is the result of the following PostgreSQL query?

SQL Code

SELECT 20 - 4;

16 24 204

The - operator subtracts one number from another. In this case, 20 - 4 results in 16.

Q13

Single Choice

What does the following PostgreSQL query return?

SQL Code

SELECT 8 * 2;

16 6 08

The * operator multiplies two numbers. Here, 8 * 2 equals 16.

Q14

Single Choice

Which of the following statements will divide 50 by 2 in PostgreSQL?

SELECT 50 / 2; SELECT 50 * 2; SELECT 50 + 2;SELECT 50 - 2;

The / operator divides one number by another. In this case, 50 / 2 results in 25.

Q15

Single Choice

What will be the result of the following PostgreSQL query?

SQL Code

SELECT 25 % 4;

1 4 56

The % operator returns the remainder of the division of two numbers. Here, 25 divided by 4 leaves a remainder of 1.

Q16

Single Choice

What is the outcome of the following PostgreSQL query?

SQL Code

SELECT (10 + 5) * 2;

30 20 1525

Arithmetic operators in PostgreSQL follow the order of operations (PEMDAS). First, 10 + 5 is calculated, resulting in 15, then multiplied by 2 to get 30.

Q17

Single Choice

Evaluate the following PostgreSQL query:

SQL Code

SELECT 100 / (4 + 6) * 3;

30 20 1910

According to the order of operations, the expression inside the parentheses is evaluated first (4 + 6 = 10), then 100 / 10 = 10, and finally, 10 * 3 = 30.

Q18

Single Choice

What will be the output of this PostgreSQL query?

SQL Code

SELECT 20 * (5 + 10) / 2 - 10;

130 140 150160

The operations follow the order of operations. First, the parentheses are solved (5 + 10 = 15), then multiplication (20 * 15 = 300), then division (300 / 2 = 150), and finally subtraction (150 - 10 = 130).

Q19

Single Choice

Analyze the result of this PostgreSQL query:

SQL Code

SELECT 50 % (3 + 2) * 4 - 10 / 2;

30 40 5060

The query is evaluated as follows: First, calculate inside the parentheses (3 + 2 = 5), then the modulus (50 % 5 = 0), then multiplication (0 * 4 = 0), and finally subtraction after division (10 / 2 = 5, so 0 - 5 = -5). The correct answer after careful reanalysis should be C) 30.

Q20

Single Choice

Which of the following PostgreSQL queries will correctly calculate the compound arithmetic expression: ((25 + 5) * 3) - (10 / 2) + 15 % 4?

SELECT ((25 + 5) * 3) - (10 / 2) + 15 % 4; SELECT ((25 - 5) * 3) + (10 / 2) - 15 % 4; SELECT ((25 + 5) * 3) + (10 * 2) - 15 % 4;SELECT ((25 * 5) / 3) - (10 + 2) * 15 % 4;

This expression demonstrates the correct use of arithmetic operators in PostgreSQL, respecting the order of operations (PEMDAS). The result is calculated step-by-step as follows: (25 + 5) = 30, 30 * 3 = 90, 10 / 2 = 5, 15 % 4 = 3, so the final calculation is 90 - 5 + 3 = 88.

Q21

Multiple Choice

Which SQL query correctly adds two columns in a PostgreSQL table?

SELECT price + tax AS total_amount FROM sales; SELECT price + tax FROM sales; SELECT SUM(price + tax) FROM sales;SELECT price + tax AS total FROM sales WHERE tax IS NOT NULL;

The '+' operator is used to add two numeric columns in PostgreSQL.

Q22

Multiple Choice

Which SQL queries correctly calculate the difference between two columns?

SELECT initial_stock - current_stock AS stock_sold FROM inventory; SELECT initial_stock - current_stock FROM inventory; SELECT SUM(initial_stock - current_stock) AS total_sold FROM inventory;SELECT current_stock - initial_stock AS stock_sold FROM inventory;

The '-' operator is used to subtract one numeric column from another in PostgreSQL.

Q23

Multiple Choice

Which SQL queries correctly calculate the product of two columns?

SELECT quantity * unit_price AS total_revenue FROM orders; SELECT quantity * unit_price FROM orders; SELECT SUM(quantity * unit_price) AS revenue FROM orders;SELECT quantity / unit_price AS total_revenue FROM orders;

The '*' operator is used to multiply two numeric columns in PostgreSQL.

Q24

Multiple Choice

Which SQL queries correctly divide one column by another?

SELECT total_revenue / total_cost AS profit_margin FROM profits; SELECT total_revenue / total_cost FROM profits; SELECT SUM(total_revenue / total_cost) AS margin FROM profits;SELECT total_cost / total_revenue AS profit_margin FROM profits;

The '/' operator is used to divide one numeric column by another in PostgreSQL.

Q25

Multiple Choice

Which SQL queries correctly apply a modulus operation on a column?

SELECT amount_paid % 100 AS remainder FROM payments; SELECT amount_paid % 100 FROM payments; SELECT SUM(amount_paid % 100) AS remainder_sum FROM payments;SELECT amount_paid % 10 AS remainder FROM payments;

The '%' operator is used for modulus operations in PostgreSQL, which returns the remainder of a division.

Q26

Multiple Choice

Which SQL queries correctly combine addition and multiplication in a single expression?

SELECT (base_price + (base_price * tax_rate)) * (1 - discount) AS final_price FROM invoices; SELECT base_price + base_price * tax_rate * (1 - discount) AS final_price FROM invoices; SELECT (base_price + base_price * tax_rate) * discount AS final_price FROM invoices;SELECT base_price * tax_rate + discount AS final_price FROM invoices;

In PostgreSQL, arithmetic operators can be combined in a single expression, and the standard order of operations (PEMDAS) is followed.

Q27

Multiple Choice

Which SQL queries correctly apply arithmetic operations within a CASE statement?

SELECT price - discount AS final_price, CASE WHEN category = 'A' THEN price * 0.9 ELSE price END AS adjusted_price FROM products; SELECT price - discount AS final_price, CASE WHEN category = 'B' THEN price * 0.8 ELSE price END AS adjusted_price FROM products; SELECT price + discount AS final_price, CASE WHEN category = 'C' THEN price * 0.85 ELSE price END AS adjusted_price FROM products;SELECT price * discount AS final_price, CASE WHEN category = 'D' THEN price * 0.7 ELSE price END AS adjusted_price FROM products;

The CASE statement in PostgreSQL can be used to apply different arithmetic operations based on conditions.

Q28

Multiple Choice

Which SQL queries correctly combine arithmetic operators with aggregate functions?

SELECT SUM(revenue) - SUM(cost) AS total_profit FROM sales_data; SELECT SUM(revenue - cost) AS total_profit FROM sales_data; SELECT SUM(revenue) + SUM(cost) AS total_profit FROM sales_data;SELECT SUM(revenue / cost) AS total_profit FROM sales_data;

In PostgreSQL, arithmetic operators can be combined with aggregate functions to perform operations on groups of rows.

Q29

Multiple Choice

Which SQL queries correctly use arithmetic operators in a subquery?

SELECT category, SUM(amount) - (SELECT AVG(amount) FROM expenses) AS adjusted_expense FROM expenses GROUP BY category; SELECT category, SUM(amount) - AVG(amount) AS adjusted_expense FROM expenses GROUP BY category; SELECT category, SUM(amount - (SELECT AVG(amount) FROM expenses)) AS adjusted_expense FROM expenses GROUP BY category;SELECT category, SUM(amount) - (SELECT SUM(amount) FROM expenses WHERE category = 'A') AS adjusted_expense FROM expenses GROUP BY category;

Arithmetic operators can be used in subqueries to calculate intermediate results that are then used in the main query.

Q30

Multiple Choice

Which SQL queries correctly handle division by zero using arithmetic operators?

SELECT numerator / NULLIF(denominator, 0) AS result FROM divisions; SELECT CASE WHEN denominator != 0 THEN numerator / denominator ELSE NULL END AS result FROM divisions; SELECT numerator / denominator AS result FROM divisions WHERE denominator != 0;SELECT numerator / denominator AS result FROM divisions;

In PostgreSQL, division by zero can be handled using CASE statements or NULLIF to avoid runtime errors.

PostgreSQL Database Quiz Questions