SQL has many built-in functions for performing processing on string or numeric

data. Following is the list of all useful SQL built-in functions −

 SQL COUNT Function - The SQL COUNT aggregate function is used to

count the number of rows in a database table.
 SQL MAX Function - The SQL MAX aggregate function allows us to
select the highest (maximum) value for a certain column.
 SQL MIN Function - The SQL MIN aggregate function allows us to
select the lowest (minimum) value for a certain column.
 SQL AVG Function - The SQL AVG aggregate function selects the
average value for certain table column.
 SQL SUM Function - The SQL SUM aggregate function allows selecting
the total for a numeric column.
 SQL SQRT Functions - This is used to generate a square root of a given
number.
 SQL RAND Function - This is used to generate a random number using
SQL command.
 SQL CONCAT Function - This is used to concatenate any string inside
any SQL command.
 SQL Numeric Functions - Complete list of SQL functions required to
manipulate numbers in SQL.
 SQL String Functions - Complete list of SQL functions required to
manipulate strings in SQL.
SQL - Date Functions

Sr.No. Function & Description

ADDDATE()
1
Adds dates
ADDTIME()
2
Adds time
CONVERT_TZ()
3
Converts from one timezone to another
CURDATE()
4
Returns the current date
CURRENT_DATE(), CURRENT_DATE
5
Synonyms for CURDATE()
CURRENT_TIME(), CURRENT_TIME
6
Synonyms for CURTIME()
CURRENT_TIMESTAMP(), CURRENT_TIMESTAMP
7
Synonyms for NOW()
CURTIME()
8
Returns the current time
DATE_ADD()
9
Adds two dates
DATE_FORMAT()
10
Formats date as specified
DATE_SUB()
11
Subtracts two dates
DATE()
12
Extracts the date part of a date or datetime expression
DATEDIFF()
13
Subtracts two dates
DAY()
14
Synonym for DAYOFMONTH()
15 DAYNAME()
 Returns the name of the weekday
DAYOFMONTH()
16
Returns the day of the month (1-31)
DAYOFWEEK()
17
Returns the weekday index of the argument
DAYOFYEAR()
18
Returns the day of the year (1-366)
EXTRACT
19
Extracts part of a date
FROM_DAYS()
20
Converts a day number to a date
FROM_UNIXTIME()
21
Formats date as a UNIX timestamp
HOUR()
22
Extracts the hour
LAST_DAY
23
Returns the last day of the month for the argument
LOCALTIME(), LOCALTIME
24
Synonym for NOW()
LOCALTIMESTAMP, LOCALTIMESTAMP()
25
Synonym for NOW()
MAKEDATE()
26
Creates a date from the year and day of year
MAKETIME
27
MAKETIME()
MICROSECOND()
28
Returns the microseconds from argument
MINUTE()
29
Returns the minute from the argument
MONTH()
30
Return the month from the date passed
31 MONTHNAME()
 Returns the name of the month
NOW()
32
Returns the current date and time
PERIOD_ADD()
33
Adds a period to a year-month
PERIOD_DIFF()
34
Returns the number of months between periods
QUARTER()
35
Returns the quarter from a date argument
SEC_TO_TIME()
36
Converts seconds to 'HH:MM:SS' format
SECOND()
37
Returns the second (0-59)
STR_TO_DATE()
38
Converts a string to a date
SUBDATE()
39
When invoked with three arguments a synonym for DATE_SUB()
SUBTIME()
40
Subtracts times
SYSDATE()
41
Returns the time at which the function executes
TIME_FORMAT()
42
Formats as time
TIME_TO_SEC()
43
Returns the argument converted to seconds
TIME()
44
Extracts the time portion of the expression passed
TIMEDIFF()
45
Subtracts time
46 TIMESTAMP()

With a single argument this function returns the date or datetime expression. With two
 arguments, the sum of the arguments
TIMESTAMPADD()
47
Adds an interval to a datetime expression
TIMESTAMPDIFF()
48
Subtracts an interval from a datetime expression
TO_DAYS()
49
Returns the date argument converted to days
UNIX_TIMESTAMP()
50
Returns a UNIX timestamp
UTC_DATE()
51
Returns the current UTC date
UTC_TIME()
52
Returns the current UTC time
UTC_TIMESTAMP()
53
Returns the current UTC date and time
WEEK()
54
Returns the week number
WEEKDAY()
55
Returns the weekday index
WEEKOFYEAR()
56
Returns the calendar week of the date (1-53)
YEAR()
57
Returns the year
YEARWEEK()
58
Returns the year and week

SQL - Group By

The SQL GROUP BY clause is used in collaboration with the SELECT

statement to arrange identical data into groups. This GROUP BY clause follows
the WHERE clause in a SELECT statement and precedes the ORDER BY
clause.

Syntax

The basic syntax of a GROUP BY clause is shown in the following code block.
The GROUP BY clause must follow the conditions in the WHERE clause and
must precede the ORDER BY clause if one is used.

SELECT column1, column2

FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2
ORDER BY column1, column2

Consider the CUSTOMERS table is having the following records −

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

If you want to know the total amount of the salary on each customer, then the GROUP BY
query would be as follows.

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS

GROUP BY NAME;

This would produce the following result −

+----------+-------------+
| NAME | SUM(SALARY) |
+----------+-------------+
| Chaitali | 6500.00 |
| Hardik | 8500.00 |
| kaushik | 2000.00 |
| Khilan | 1500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 2000.00 |
+----------+-------------+

Now, let us look at a table where the CUSTOMERS table has the following records with
duplicate names −

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Ramesh | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | kaushik | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Now again, if you want to know the total amount of salary on each customer, then the
GROUP BY query would be as follows −

SQL> SELECT NAME, SUM(SALARY) FROM CUSTOMERS

GROUP BY NAME;

This would produce the following result −

+---------+-------------+
| NAME | SUM(SALARY) |
+---------+-------------+
| Hardik | 8500.00 |
| kaushik | 8500.00 |
| Komal | 4500.00 |
| Muffy | 10000.00 |
| Ramesh | 3500.00 |
+---------+-------------+

SQL - ORDER BY Clause

The SQL ORDER BY clause is used to sort the data in ascending or descending order, based
on one or more columns. Some databases sort the query results in an ascending order by
default.
Syntax

The basic syntax of the ORDER BY clause is as follows −

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

You can use more than one column in the ORDER BY clause. Make sure whatever column
you are using to sort that column should be in the column-list.

Example

Consider the CUSTOMERS table having the following records −

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

The following code block has an example, which would sort the result in an ascending order
by the NAME and the SALARY −

SQL> SELECT * FROM CUSTOMERS

ORDER BY NAME, SALARY;

This would produce the following result −

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
+----+----------+-----+-----------+----------+

The following code block has an example, which would sort the result in the descending
order by NAME.

SQL> SELECT * FROM CUSTOMERS

ORDER BY NAME DESC;

This would produce the following result −

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
+----+----------+-----+-----------+----------+

SQL - Having Clause

The HAVING Clause enables you to specify conditions that filter which group results
appear in the results.

The WHERE clause places conditions on the selected columns, whereas the HAVING clause
places conditions on groups created by the GROUP BY clause.

Syntax

The following code block shows the position of the HAVING Clause in a query.

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

The HAVING clause must follow the GROUP BY clause in a query and must also precede
the ORDER BY clause if used. The following code block has the syntax of the SELECT
statement including the HAVING clause −

SELECT column1, column2

FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Example

Consider the CUSTOMERS table having the following records.

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Following is an example, which would display a record for a similar age count that would be
more than or equal to 2.

SQL > SELECT ID, NAME, AGE, ADDRESS, SALARY

FROM CUSTOMERS
GROUP BY age
HAVING COUNT(age) >= 2;

This would produce the following result −

+----+--------+-----+---------+---------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+--------+-----+---------+---------+
| 2 | Khilan | 25 | Delhi | 1500.00 |
+----+--------+-----+---------+---------+

SQL - Using Joins

The SQL Joins clause is used to combine records from two or more tables in a database. A
JOIN is a means for combining fields from two tables by using values common to each.

Consider the following two tables −

Table 1 − CUSTOMERS Table

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 − ORDERS Table

+-----+---------------------+-------------+--------+
|OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+

Now, let us join these two tables in our SELECT statement as shown below.
SQL> SELECT ID, NAME, AGE, AMOUNT
FROM CUSTOMERS, ORDERS
WHERE CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result.

+----+----------+-----+--------+
| ID | NAME | AGE | AMOUNT |
+----+----------+-----+--------+
| 3 | kaushik | 23 | 3000 |
| 3 | kaushik | 23 | 1500 |
| 2 | Khilan | 25 | 1560 |
| 4 | Chaitali | 25 | 2060 |
+----+----------+-----+--------+

Here, it is noticeable that the join is performed in the WHERE clause. Several
operators can be used to join tables, such as =, <, >, <>, <=, >=, !=, BETWEEN,
LIKE, and NOT; they can all be used to join tables. However, the most common
operator is the equal to symbol.

There are different types of joins available in SQL −

 INNER JOIN − returns rows when there is a match in both tables.

 LEFT JOIN − returns all rows from the left table, even if there are no
matches in the right table.
 RIGHT JOIN − returns all rows from the right table, even if there are no
matches in the left table.
 FULL JOIN − returns rows when there is a match in one of the tables.
 SELF JOIN − is used to join a table to itself as if the table were two
tables, temporarily renaming at least one table in the SQL statement.
 CARTESIAN JOIN − returns the Cartesian product of the sets of records
from the two or more joined tables.

SQL - INNER JOINS

The most important and frequently used of the joins is the INNER JOIN. They are also
referred to as an EQUIJOIN.
The INNER JOIN creates a new result table by combining column values of two tables
table1andtable2

based upon the join-predicate. The query compares each row of table1 with each row of
table2 to find all pairs of rows which satisfy the join-predicate. When the join-predicate is
satisfied, column values for each matched pair of rows of A and B are combined into a result
row.

Syntax

The basic syntax of the INNER JOIN is as follows.

SELECT table1.column1, table2.column2...

FROM table1
INNER JOIN table2
ON table1.common_field = table2.common_field;

Example

Consider the following two tables.

Table 1 − CUSTOMERS Table is as follows.

+----+----------+-----+-----------+----------+
| ID | NAME | AGE | ADDRESS | SALARY |
+----+----------+-----+-----------+----------+
| 1 | Ramesh | 32 | Ahmedabad | 2000.00 |
| 2 | Khilan | 25 | Delhi | 1500.00 |
| 3 | kaushik | 23 | Kota | 2000.00 |
| 4 | Chaitali | 25 | Mumbai | 6500.00 |
| 5 | Hardik | 27 | Bhopal | 8500.00 |
| 6 | Komal | 22 | MP | 4500.00 |
| 7 | Muffy | 24 | Indore | 10000.00 |
+----+----------+-----+-----------+----------+

Table 2 − ORDERS Table is as follows.

+-----+---------------------+-------------+--------+
| OID | DATE | CUSTOMER_ID | AMOUNT |
+-----+---------------------+-------------+--------+
| 102 | 2009-10-08 00:00:00 | 3 | 3000 |
| 100 | 2009-10-08 00:00:00 | 3 | 1500 |
| 101 | 2009-11-20 00:00:00 | 2 | 1560 |
| 103 | 2008-05-20 00:00:00 | 4 | 2060 |
+-----+---------------------+-------------+--------+

Now, let us join these two tables using the INNER JOIN as follows −

SQL> SELECT ID, NAME, AMOUNT, DATE

FROM CUSTOMERS
INNER JOIN ORDERS
ON CUSTOMERS.ID = ORDERS.CUSTOMER_ID;

This would produce the following result.

+----+----------+--------+---------------------+
| ID | NAME | AMOUNT | DATE |
+----+----------+--------+---------------------+
| 3 | kaushik | 3000 | 2009-10-08 00:00:00 |
| 3 | kaushik | 1500 | 2009-10-08 00:00:00 |
| 2 | Khilan | 1560 | 2009-11-20 00:00:00 |
| 4 | Chaitali | 2060 | 2008-05-20 00:00:00 |
+----+----------+--------+---------------------+