Test Your PostgreSQL != or < > Operator Knowledge with This Quiz

Progress

True / False

In PostgreSQL, the <> operator is used to check if two values are not equal.

True False

The <> operator in PostgreSQL is used to compare two values and returns TRUE if they are not equal.

True / False

The != operator in PostgreSQL serves the same purpose as the <> operator.

True False

Both != and <> are used to check if two values are not equal in PostgreSQL.

True / False

In PostgreSQL, the expression 5 <> 5 evaluates to TRUE.

True False

The expression 5 <> 5 evaluates to FALSE because 5 is equal to 5.

True / False

In PostgreSQL, NULL <> value evaluates to TRUE.

True False

Any comparison with NULL in PostgreSQL results in NULL, which is not TRUE or FALSE but unknown.

True / False

In PostgreSQL, you can use the <> operator to filter rows where a column value is not equal to a specified value.

True False

The <> operator can be used in WHERE clauses to filter rows where the column value does not match the specified value.

True / False

In PostgreSQL, the query SELECT * FROM table WHERE column != 'value' will return all rows where the column is not equal to 'value'.

True False

The query uses the != operator to filter rows where column does not equal 'value'.

True / False

In PostgreSQL, combining <> with AND and OR operators allows for complex filtering conditions.

True False

You can combine <> with AND and OR operators to create complex logical conditions for filtering data.

True / False

In PostgreSQL, the expression column1 <> column2 will always evaluate to TRUE if column1 and column2 are different.

True False

The expression column1 <> column2 evaluates to TRUE if column1 and column2 have different values.

True / False

In PostgreSQL, using <> in an indexed column's query condition can utilize the index to improve query performance.

True False

If a column is indexed, using <> in query conditions can leverage the index to improve performance by quickly locating rows that do not match the specified value.

Q10

True / False

In PostgreSQL, the <> and != operators can be used interchangeably in all contexts without any difference in functionality.

True False

In PostgreSQL, <> and != are functionally equivalent and can be used interchangeably to check for inequality.

Q11

Single Choice

What does the <> operator in PostgreSQL signify?

Equal to Greater than Not equal toLess than

In PostgreSQL, the <> operator is used to check if two expressions are not equal.

Q12

Single Choice

What will be the result of the following query in PostgreSQL?

SQL Code

SELECT 'apple' <> 'banana';

TRUE FALSE NULLNULL

The <> operator checks if 'apple' is not equal to 'banana'. Since they are different, the result is TRUE.

Q13

Single Choice

In PostgreSQL, which of the following is equivalent to the <> operator?

== != ==!=!

In PostgreSQL, both <> and != can be used to check for inequality between two values.

Q14

Single Choice

Given the following table employees in PostgreSQL:

SQL Code

| employee_id | name | salary |
|-------------|----------|--------|
| 1 | John | 50000 |
| 2 | Alice | 55000 |
| 3 | Bob | 50000 |
Which query will return all employees whose salary is not equal to 50000?

SELECT * FROM employees WHERE salary = 50000; SELECT * FROM employees WHERE salary != 50000; SELECT * FROM employees WHERE salary > 50000;SELECT * FROM employees WHERE salary <> 50000;

The <> operator is used to select rows where the salary is not equal to 50000.

Q15

Single Choice

What will be the output of the following PostgreSQL query?

SQL Code

SELECT 10 <> 10;

TRUE FALSE NULLNULL

The <> operator checks if 10 is not equal to 10. Since they are equal, the result is FALSE.

Q16

Single Choice

Which PostgreSQL query will return all records where the status column is not 'active'?

SELECT * FROM users WHERE status <> 'active'; SELECT * FROM users WHERE status = 'active'; SELECT * FROM users WHERE status != 'inactive'SELECT * FROM users WHERE status = 'inactive';

The <> operator is used to select rows where the status column value is not 'active'.

Q17

Single Choice

Consider the following PostgreSQL query:

SQL Code

SELECT * FROM orders WHERE order_date <> '2024-01-01';
Which of the following scenarios is covered by this query?

Fetching orders only from '2024-01-01' Excluding orders from '2024-01-01' Fetching orders only from '2024-01-01' and '2024-02-01'Fetching orders where order_date is NULL

The <> operator ensures that only orders with dates other than '2024-01-01' are selected.

Q18

Single Choice

What will the following PostgreSQL query return?

SQL Code

SELECT 5 != 3, 'a' <> 'A', NULL <> NULL;

TRUE, TRUE, TRUE TRUE, FALSE, TRUE TRUE, TRUE, NULLTRUE, FALSE, NULL

5 is not equal to 3, so TRUE; 'a' is not equal to 'A', but PostgreSQL is case-sensitive, so FALSE; NULL is not equal to NULL, so the result is NULL.

Q19

Single Choice

In PostgreSQL, how does the <> operator behave when comparing a value with NULL?

Always returns TRUE Always returns FALSE Returns NULLReturns NULL

In PostgreSQL, any comparison with NULL, including using the <> operator, results in NULL.

Q20

Single Choice

Given the PostgreSQL table products:

SQL Code

| product_id | name | price |
|------------|-----------|-------|
| 1 | Laptop | 1500 |
| 2 | Keyboard | 100 |
| 3 | Mouse | 50 |
| 4 | Monitor | 300 |
Which of the following queries correctly retrieves all products that do not have a price of 300 or 50?

SELECT * FROM products WHERE price != 300 AND price != 50; SELECT * FROM products WHERE price <> 300 OR price <> 50; SELECT * FROM products WHERE price NOT IN (300, 50);SELECT * FROM products WHERE price IN (300, 50);

The NOT IN operator is used to exclude rows where the price is either 300 or 50. The <> operator could be used, but it would require combining conditions with AND, which can be less efficient.

Q21

Multiple Choice

Identify the SQL scripts that correctly use the '<>' or '!=' operator to filter numeric values in PostgreSQL.

SELECT * FROM products WHERE price <> 50; SELECT * FROM products WHERE price != 50; SELECT * FROM products WHERE price = 50;SELECT * FROM products WHERE price <> '50';

The '<>' or '!=' operators are used to filter rows based on non-equal comparisons. The correct scripts will demonstrate how to use these operators effectively with numeric values in PostgreSQL.

Q22

Multiple Choice

Select the SQL scripts that correctly use the '<>' or '!=' operator with text values in PostgreSQL.

SELECT * FROM customers WHERE city <> 'New York'; SELECT * FROM customers WHERE city != 'New York'; SELECT * FROM customers WHERE city = 'New York';SELECT * FROM customers WHERE city <> 'NYC';

Using the '<>' or '!=' operators with text values allows you to filter rows based on non-equal comparisons. The correct scripts will demonstrate how to use these operators with text in PostgreSQL.

Q23

Multiple Choice

Determine the SQL scripts that correctly use the '<>' or '!=' operator with date values in PostgreSQL.

SELECT * FROM orders WHERE order_date <> '2023-01-01'; SELECT * FROM orders WHERE order_date != '2023-01-01'; SELECT * FROM orders WHERE order_date = '2023-01-01';SELECT * FROM orders WHERE order_date <> '01-JAN-2023';

The '<>' or '!=' operators can be used with date values to filter rows based on non-equal comparisons. The correct scripts will demonstrate how to use these operators with dates in PostgreSQL.

Q24

Multiple Choice

Identify the SQL scripts that correctly use the '<>' or '!=' operator with JOINs in PostgreSQL.

SELECT * FROM employees e JOIN departments d ON e.department_id = d.department_id WHERE d.department_name <> 'HR'; SELECT * FROM employees WHERE department_id != (SELECT department_id FROM departments WHERE department_name = 'HR'); SELECT * FROM employees e JOIN departments d ON e.department_id = d.department_id WHERE d.department_name != 'HR';SELECT * FROM employees WHERE department_id = (SELECT department_id FROM departments WHERE department_name = 'HR');

The '<>' or '!=' operators can be used with JOINs to filter rows based on non-equal comparisons in related tables. The correct scripts will demonstrate how to use these operators with JOINs in PostgreSQL.

Q25

Multiple Choice

Select the SQL scripts that correctly use the '<>' or '!=' operator with NULL values in PostgreSQL.

SELECT * FROM payments WHERE payment_date IS NOT NULL; SELECT * FROM payments WHERE payment_date != NULL; SELECT * FROM payments WHERE payment_date <> NULL;SELECT * FROM payments WHERE payment_date IS NULL;

The '<>' or '!=' operators are generally not used with NULL values as NULL comparison requires special handling. The correct scripts will demonstrate the appropriate way to filter out NULL values using IS NOT NULL in PostgreSQL.

Q26

Multiple Choice

Determine the SQL scripts that correctly use the '<>' or '!=' operator with aggregate functions in PostgreSQL.

SELECT department_id FROM employees GROUP BY department_id HAVING AVG(salary) <> 50000; SELECT department_id FROM employees GROUP BY department_id HAVING AVG(salary) != 50000; SELECT department_id FROM employees GROUP BY department_id HAVING AVG(salary) = 50000;SELECT department_id FROM employees GROUP BY department_id HAVING AVG(salary) IS NOT 50000;

The '<>' or '!=' operators can be used with aggregate functions to filter groups based on non-equal conditions. The correct scripts will demonstrate how to use these operators with aggregate functions in PostgreSQL.

Q27

Multiple Choice

Identify the SQL scripts that correctly use the '<>' or '!=' operator with CASE statements in PostgreSQL.

SELECT product_id, category, CASE WHEN category <> 'Electronics' THEN 'Non-Electronics' ELSE 'Electronics' END AS product_type FROM products; SELECT product_id, category, CASE WHEN category != 'Electronics' THEN 'Non-Electronics' ELSE 'Electronics' END AS product_type FROM products; SELECT product_id, category, CASE WHEN category = 'Electronics' THEN 'Electronics' ELSE 'Non-Electronics' END AS product_type FROM products;SELECT product_id, category, CASE WHEN category <> 'Electronics' THEN 'Non-Electronics' END AS product_type FROM products;

The '<>' or '!=' operators can be used within CASE statements to apply different conditions based on non-equal comparisons. The correct scripts will demonstrate how to use these operators with CASE in PostgreSQL.

Q28

Multiple Choice

Determine the SQL scripts that correctly use the '<>' or '!=' operator with LIMIT OFFSET in PostgreSQL.

SELECT * FROM employees WHERE salary <> 60000 ORDER BY employee_id LIMIT 10 OFFSET 0; SELECT * FROM employees WHERE salary != 60000 ORDER BY employee_id LIMIT 10 OFFSET 0; SELECT * FROM employees WHERE salary = 60000 ORDER BY employee_id LIMIT 10 OFFSET 0;SELECT * FROM employees WHERE salary <> 60000 ORDER BY employee_id LIMIT 10 OFFSET 5;

The '<>' or '!=' operators can be used with LIMIT OFFSET to filter and paginate results based on non-equal conditions. The correct scripts will demonstrate how to use these operators with LIMIT OFFSET in PostgreSQL.

Q29

Multiple Choice

Identify the SQL scripts that correctly use the '<>' or '!=' operator with EXISTS in PostgreSQL.

SELECT * FROM customers WHERE NOT EXISTS (SELECT 1 FROM orders WHERE orders.customer_id = customers.customer_id); SELECT * FROM customers WHERE customer_id <> (SELECT customer_id FROM orders); SELECT * FROM customers WHERE customer_id != ALL (SELECT customer_id FROM orders);SELECT * FROM customers WHERE NOT EXISTS (SELECT customer_id FROM orders WHERE orders.customer_id = customers.customer_id);

The '<>' or '!=' operators can be combined with EXISTS to filter rows based on non-equal conditions in related tables. The correct scripts will demonstrate how to use these operators with EXISTS in PostgreSQL.

Q30

Multiple Choice

Determine the SQL scripts that correctly use the '<>' or '!=' operator with subqueries in PostgreSQL.

SELECT * FROM orders WHERE order_amount <> (SELECT AVG(order_amount) FROM orders); SELECT * FROM orders WHERE order_amount != (SELECT AVG(order_amount) FROM orders); SELECT * FROM orders WHERE order_amount = (SELECT AVG(order_amount) FROM orders);SELECT * FROM orders WHERE order_amount <> ALL (SELECT AVG(order_amount) FROM orders);

The '<>' or '!=' operators can be used with subqueries to compare values with the results of the subquery. The correct scripts will demonstrate how to use these operators with subqueries in PostgreSQL.

PostgreSQL Database Quiz Questions