Updated March 10, 2023

## Introduction to SQL NULLIF()

NULLIF() is a comparison function in standard query language (SQL) that takes two expressions as arguments and returns NULL if the two expressions are equal. The data type of the NULL value returned is the same as the first expression. If the expressions are not equal to each other, NULLIF() returns the first expression. This function can be considered as a special case of CASE statements where the statement returns NULL if two given expressions are equal, else returns the first expression.

We should note that NULLIF() function is not supported in all SQL databases. It is currently supported in SQL Server, Azure SQL server, and Parallel databases only.

**Syntax and parameters:**

The basic syntax for using NULLIF() function in SQL is as follows :

`NULLIF(first_expression,second_expression);`

The parameters used in the above syntax are as follows :

- First_expression: Any valid scalar expression
- Second_expression: Any valid scalar expression

Since we have already mentioned that the NULLIF() function is a special case of CASE statements, here is an illustration of NULLIF as a case statement.

```
CASE WHEN first_expression = second_expression
THEN NULL
ELSE
first_expression
END;
```

Having discussed the syntax, let us try some examples using NULLIF() to understand it in great detail.

### Examples of SQL NULLIF()

Let us discuss examples of SQL NULLIF().

#### Example #1

Simple SQL query to illustrate NULLIF() functionality using two integer type arguments.

```
Declare @X Int, @Y Int
Select @X = 1, @Y = 2
Select NULLIF(@X, @Y) [Result];
```

The case statement equivalent to the above NULLIF() function is as follows :

```
CASE WHEN X = Y
THEN NULL
ELSE
X
END;
```

In the above code snippet, we have passed X =1 and Y = 2 as arguments to NULLIF() function. Since they are not equal, the function returns the first expression i.e. value of X. Next, let us try to pass equal values of X and Y.

```
Declare @X Int, @Y Int
Select @X = 2, @Y = 2
Select NULLIF(@X, @Y) [Result];
```

When we pass equal arguments, the NULLIF() function returns NULL.

#### Example #2

Simple SQL query to illustrate NULLIF() functionality using two VARCHAR type arguments.

```
Declare @Fruit_1 VARCHAR(255), @Fruit_2 VARCHAR(255)
Select @Fruit_1 = 'Apple', @Fruit_2 = 'Oranges'
Select NULLIF(@Fruit_1, @Fruit_2) [Result];
```

The case statement equivalent to the above NULLIF() function is as follows :

```
CASE WHEN Fruit_1 = Fruit_2
THEN NULL
ELSE
Fruit_1
END;
```

In the code snippet, since the values of arguments are not the same, the function returns the first expression that is fruit_1.

```
Declare @Fruit_1 VARCHAR(255), @Fruit_2 VARCHAR(255)
Select @Fruit_1 = 'Apple', @Fruit_2 = 'Apple'
Select NULLIF(@Fruit_1, @Fruit_2) [Result];
```

When we pass equal arguments, the NULLIF() function returns NULL.

By now we have got a decent understanding of the NULLIF() function. But to put this understanding to some usage, here are some more examples to illustrate the use of NULLIF() function in real business problems.

Let us first create a table called “sales” that contains details of sales made by a salesperson. We will use it for illustration purposes. You may use the following code snippet for creating the said table.

```
CREATE TABLE sales
(
salesperson_id integer NOT NULL,
salesperson character varying(255) NOT NULL,
store_state character varying(255) NOT NULL,
sales_target numeric NOT NULL,
sales_current numeric NOT NULL,
);
```

Having successfully created the table, let us now insert some random records in it to use in examples. You may use the following code snippet to perform the task.

```
INSERT INTO sales
([salesperson_id]
,[salesperson]
,[store_state]
,[sales_target]
,[sales_current])
VALUES
(101,'Danish K','KA',10000,10000),
(102,'Rashmi Sharma','DL',23000,18000),
(103,'Mohak Patel','MH',21000,21000),
(104,'Devika Ramaswamy','TN',10000,8000),
(105,'Reema Ray','WB',0,10000);
```

After a few insertion operations, the data in the sales table looks something like this :

`SELECT * FROM sales;`

#### Example #3

SQL query to return sales target of a salesperson who has not achieved his or her target.

```
SELECT
salesperson,
NULLIF(sales_target,sales_current) AS 'target to be achieved'
FROM sales;
```

In this example, we have used NULLIF to return a null value if the salesperson has completed his or her targets and return sales_target for the ones who are yet to complete theirs.

#### Example #4

SQL query to return average sales target for the salesperson who has not achieved their sales target.

```
SELECT
AVG(COALESCE(NULLIF(sales_target,sales_current),0.00))
AS 'Avg target to be achieved'
FROM sales;
```

In the above example, we have first used NULLIF to return a null value if the salesperson has completed his or her targets and return sales_target for the ones who are yet to complete theirs. Then used COALESCE to convert “NULL” into (0.00) and then finally applied the AVG summary function.

#### Example #5

SQL query to return the remaining sales target for each salesperson.

```
SELECT salesperson,
((COALESCE(NULLIF(sales_target,sales_current),sales_target))-sales_current)
AS 'targets to be achieved'
FROM sales;
```

In the previous examples, we have straightforwardly considered sales targets without considering the current status of sales targets met by the individual salesperson. But in this example, we have tried to calculate the remaining target by using the NULLIF. We can do it right away by subtracting sales_current from sales_target. But it has been done this way to illustrate use of NULLIF() along with COALESCE function.

### Conclusion

NULLIF() is a flow control function that takes two arguments and examines if the given arguments are equal or not. If they are equal, it returns NULL value of data type similar to the first argument otherwise returns the first expression.

### Recommended Articles

We hope that this EDUCBA information on “SQL NULLIF()” was beneficial to you. You can view EDUCBA’s recommended articles for more information.