Updated March 15, 2023

## Introduction to SQL MOD()

The MOD function in standard query language (SQL) takes two arguments of numeric data type, the first argument as dividend and second argument as divisor and returns the remainder or modulus after performing a division operation or repeated subtraction. It is similar to REMAINDER and FLOOR functions.

The basic functionality of MOD() is based on the following algebraic expression.

`m - n*(FLOOR(m/n));`

Most of the SQL databases use the above expression except the ORACLE database.

In databases where the MOD() function is not supported, especially SQL Server and Azure SQL database, we can use ‘%’ percent sign. It performs the same function.

**Syntax and parameters**

The basic syntax for writing the MOD() function is as follows:

`MOD(argument_1,argument_2);`

We can even use the following syntax in some databases where MOD is not a built-in function.

`Argument_1 % Argument_2;`

The parameters used in the above syntax are as follows:

- Argument_1: The numeric data value or expression that has to be divided. It is the dividend in classical mathematics.
- Argument_2: The numeric data value or expression that divides the first argument. It is the divisor in classical mathematics.

MOD() function can be used as a part of any SQL statement or clause that takes expressions, such as SELECT, WHERE, HAVING, etc.

### Examples

Here are a few sample queries to illustrate the use of the SQL MOD() function in different scenarios, such as completely divisible arguments, floating-point, double data types, negative numbers, etc.

#### Example #1

**SQL queries to illustrate the basic functionality of SQL MOD() function.**

`SELECT MOD(20,2);`

When we divide 20 by 2, we get a remainder of 0 since 20 is completely divisible by 2. The function does the same.

`SELECT MOD(98,3);`

The given query returns the remainder obtained by dividing 98 by 3, i.e 2.

`SELECT MOD(45,3.2);`

MOD returns remainder even when we divide floating point or double data type values. This is because MOD performs repeated subtraction and reaches the desired remainder.

**Code:**

`SELECT MOD(25.5,2);`

`SELECT MOD(51.0,25.5);`

`SELECT MOD(19,-4);`

`SELECT MOD(-19,4);`

`SELECT MOD(0,12);`

`SELECT MOD(12,0);`

Most SQL database servers throw errors when attempting to find MOD of an integer value and zero, whereas database servers such as Oracle returns the first argument or dividend.

Having discussed the basic functionality of SQL MOD() function, let us try some use cases of it.

In order to demonstrate usability of MOD(), let us first create a “sales_details” table which contains details pertaining to sales made by each salesman in the company. The code snippet for the same looks something like this :

**Code:**

```
CREATE TABLE sales_details
(
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 sales_details table. Let us now insert some random records in it to use in the examples. We can use the following code snippet to perform this task.

**Code:**

```
INSERT INTO sales_details
(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);
```

The final sales_details table after insertion operation looks something like this :

`SELECT * FROM public.sales_details`

#### Example #2

**Calculate the remainder of ratio of target and current sales status for all salespersons.**

**Code:**

```
SELECT salesperson_id,
salesperson,
store_state,
sales_target,
sales_current,
MOD(sales_target,sales_current) as "Sales Ratio"
FROM sales_details;
```

#### Example #3

**Find the details of salespersons for whom the remainder of ratio of target and current sales is less than $2000.**

**Code:**

```
SELECT salesperson_id,
salesperson,
store_state,
sales_target,
sales_current
FROM sales_details
WHERE MOD(sales_target,sales_current) < 2000;
```

</pre

#### Example #4

**Suppose the company wants to divide its salespersons into two teams Team A and Team B respectively based on their ids. If a salesperson happens to have an id which is an odd number, he/she belongs to TEAM A otherwise if TEAM B.** **Code:**

```
SELECT salesperson_id, salesperson, store_state,
CASE MOD(salesperson_id, 2)
WHEN 0 THEN 'TEAM B'
ELSE 'TEAM A'
END AS team
FROM sales_details;
```

#### Example #5

**Count the number of salespersons in each of the two teams.**

**Code:**

```
SELECT
CASE MOD(salesperson_id, 2)
WHEN 0 THEN 'Team B'
ELSE 'Team A'
END AS team,
COUNT(salesperson_id)
FROM
sales_details
GROUP BY team;
```

#### Example #6

**Suppose the company wants to divide its salespersons into three teams Team A, Team B, and Team C respectively based on their ids. Devise a strategy to divide the salespersons.**

**Code: **

```
SELECT salesperson_id, salesperson, store_state,
CASE MOD(salesperson_id, 3)
WHEN 0 THEN 'TEAM A'
WHEN 1 THEN 'TEAM B'
ELSE 'TEAM C'
END AS team
FROM sales_details;
```

#### Example #7

**Count the number of salespersons in each of the three teams.**

**Code:**

```
SELECT
CASE MOD(salesperson_id, 3)
WHEN 0 THEN 'Team A'
WHEN 1 THEN 'Team B'
ELSE 'Team C'
END AS team,
COUNT(salesperson_id)
FROM
sales_details
GROUP BY team;
```

### Conclusion

SQL MOD() function returns the remainder or modulus by dividing a numeric data value by another.

### Recommended Articles

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