How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

User Name

Log in

Help

Register

Search

Home

Forum

Blogs

What's New?

Experience

TF4U News and Announcements Programming Web Design DBMS Operating Systems Software Networking

Home

DBMS

How To Write Efficient SQL?

How To Write Efficient SQL?

by Harsh Published on 03-15-2011 07:31 PM Number of Views: 1013 Rate this article 0 Comments

10 Online

Recent posts

Share

Join Chat

1 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

This article describes some of the techniques to be adhered to while writing SQL queries. A novice developer can use some of these to write effective SQL statements. Upon using these correctly, a remarkable improvement can be seen in the performance of the queries in the output. Note: The examples in this document are based on Oracle database. 1)

Select the Most Efficient Table Name Sequence

ORACLE parser always processes table names from right to left, the table name specified last (driving table) is actually the first table processed. If more than one table is specified in a FROM clause of a SELECT statement, the table containing the lowest number of rows should be chosen as the driving table. When ORACLE processes multiple tables, it uses an internal sort/merge procedure to join those tables. First, it scans & sorts the first table (the one specified last in the FROM clause). Next, it scans the second table (the one prior to the last in the FROM clause) and merges all of the rows retrieved from the second table with those retrieved from the first table. e.g. Table TAB1 has 20,000 rows Table TAB2 has 1 row. SELECT COUNT(*) FROM TAB1, TAB2 (Best Approach) SELECT COUNT(*) FROM TAB2, TAB1 (Poor Approach) If three tables are being joined, select the intersection table as the driving table. The intersection table is the table that has many tables dependent on it.

2)

Position of Joins in the WHERE Clause

Table joins should be written first, before any condition of WHERE clause. And the conditions which filter out the maximum records should be placed at the end after the joins as the parsing is done from BOTTOM to TOP. For e.g. Least Efficient: Code:
SELECT . . . . . . . . . . . .
10 Online Recent posts Share Join Chat

2 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

FROM EMP E WHERE SAL > 50000 AND JOB = MANAGER AND 25 < (SELECT COUNT(*) FROM EMP WHERE MGR = E.EMPNO);

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Most Efficient: Code:

SELECT . . . . FROM EMP E WHERE 25 < (SELECT COUNT(*) FROM EMP WHERE MGR = E.EMPNO) AND SAL > 50000 AND JOB = MANAGER;

3)

Avoid Using * in SELECT Clause

The dynamic SQL column reference (*) gives a way to refer to all of the columns of a table. Do not use * feature because it is a very inefficient one as the * has to be converted to each column in turn. The SQL parser handles all the field references by obtaining the names of valid columns from the data dictionary & substitutes them on the command line which is time consuming. 4)

Reduce the Number of Trips to the Database

Every time a SQL statement is executed, ORACLE needs to perform many internal processing steps; the statement needs to be parsed, indexes evaluated, variables bound, and data blocks read. The more we can reduce the number of database accesses, the more overhead we can save. e.g. There are 3 distinct ways of retrieving data about employees who have employee numbers 1010 or 2020. Method 1 (Least Efficient): Code:
SELECT EMP_NAME, SALARY, GRADE FROM EMP WHERE EMP_NO = 1010; SELECT EMP_NAME, SALARY, GRADE FROM EMP WHERE EMP_NO = 2020;

Method 2 (Next Most Efficient): Code:

DECLARE CURSOR C1(E_NO NUMBER) IS SELECT EMP_NAME, SALARY, GRADE FROM EMP WHERE EMP_NO = E_NO; BEGIN OPEN C1 (1010); FETCH C1 INTO , , ; ..
10 Online Recent posts Share Join Chat

3 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

OPEN C1 (2020); FETCH C1 INTO , , ; CLOSE C1; END;

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Method 3 (Most Efficient) Code:

SELECT A.EMP_NAME, A.SALARY, A.GRADE, B.EMP_NAME, B.SALARY, B.GRADE, FROM EMP A, EMP B WHERE A.EMP_NO = 1010 AND B.EMP_NO = 2020;

Note: One simplest way to increase the number of rows of data that can be fetched with one database access (and thus reduce the number of physical calls) is to reset the ARRAYSIZE parameter in SQL*Plus, SQL*Forms & Pro*C. Suggested value is 200. 5)

Use DECODE to Reduce Processing

The DECODE statement provides a way to avoid having to scan the same rows repetitively, or to join the same table repetitively. e.g. Code:
SELECT COUNT(*), SUM(SAL) FROM EMP WHERE DEPT_NO = 0020 AND ENAME LIKE SMITH%; SELECT COUNT(*), SUM(SAL) FROM EMP WHERE DEPT_NO = 0030 AND ENAME LIKE SMITH%;

The same result can be achieved much more efficiently using DECODE: Code:
SELECT COUNT(DECODE(DEPT_NO, 0020, X, NULL)) D0020_COUNT, COUNT(DECODE(DEPT_NO, 0030, X, NULL)) D0030_COUNT, SUM(DECODE(DEPT_NO, 0020, SAL, NULL)) D0020_SAL, SUM(DECODE(DEPT_NO, 0030, SAL, NULL)) D0030_SAL FROM EMP WHERE ENAME LIKE SMITH%;

Similarly, DECODE can be used in GROUP BY or ORDER BY clause effectively 6)

Combine Simple, Unrelated Database Accesses

If there are a number of simple database queries, the performance can be improved by combining them into a single query, even if they are not related. e.g:
10 Online Recent posts Share Join Chat

4 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Code:
SELECT NAME FROM EMP WHERE EMP_NO = 1234; SELECT NAME FROM DPT WHERE DPT_NO = 10; SELECT NAME FROM CAT WHERE CAT_TYPE = 'RD';

The above three queries can be combined as shown below: Code:

SELECT E.NAME, D.NAME, C.NAME FROM CAT C, DPT D, EMP E, DUAL X WHERE NVL('X', X.DUMMY) = NVL('X', E.ROWID (+)) AND NVL('X', X.DUMMY) = NVL('X', D.ROWID (+)) AND NVL('X', X.DUMMY) = NVL('X', C.ROWID (+)) AND E.EMP_NO (+) = 1234 AND D.DEPT_NO (+) = 10 AND C.CAT_TYPE (+) = 'RD'

7)

Deleting Duplicate Records

The efficient way to delete duplicate records from a table is shown below. It takes advantage of the fact that a rows ROWID must be unique. Code:
DELETE FROM EMP E WHERE E.ROWID > (SELECT MIN (X.ROWID) FROM EMP X WHERE X.EMP_NO = E.EMP_NO);

8)

Use TRUNCATE instead of DELETE

When rows are removed from a table, under normal circumstances, the rollback segments are used to hold undo information. If we do not commit the transaction, Oracle restores the data to the state it was in before the transaction started. With TRUNCATE, no undo information is generated. Once the table is truncated, the data cannot be recovered back. It is faster and needs fewer resources. Use TRUNCATE rather than DELETE for wiping the contents of small or large tables when you need no undo information generated. 9)

Issue Frequent COMMIT statements

Whenever possible, issue frequent COMMIT statements in programs. By issuing frequent COMMIT statements, the performance of the program is enhanced and its resource requirements are minimized as COMMIT frees up the following resources: Information held in the rollback segments to undo the transaction, if necessary. All locks acquired during statement processing.
10 Online Recent posts Share

Join Chat

5 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Space in the redo log buffer cache. Overhead associated with any internal Oracle mechanisms to manage the resources in the previous three items. 10)

Counting Rows from Tables

Contrary to popular belief, COUNT(*) is faster than COUNT(1). If the rows are being returned via an index, counting the indexed column, for example, COUNT(EMPNO) is faster still. 11)

Use WHERE in Place of HAVING

Avoid including a HAVING clause in SELECT statements. The HAVING clause filters selected rows only after all rows have been fetched. This could include sorting, summing, etc. Restricting rows via the WHERE clause, rather than the HAVING clause, helps reduce these overheads. e.g. Least Efficient: Code:
SELECT REGION, AVG(LOC_SIZE) FROM LOCATION GROUP BY REGION HAVING REGION != DELHI AND REGION != NOIDA

Most Efficient: Code:

SELECT REGION, AVG(LOC_SIZE) FROM LOCATION GROUP BY REGION WHERE REGION != DELHI AND REGION != NOIDA

12)

Minimize Table Lookups in a Query

e.g: To improve performance, minimize the number of table lookups in queries, particularly if the statements include sub-query SELECTs or multi-column UPDATEs. e.g. Least Efficient: Code:
SELECT TAB_NAME FROM TABLES WHERE TAB_NAME = (SELECT TAB_NAME FROM TAB_COLUMNS WHERE VERSION = 100) AND DB_VER = (SELECT DB_VER FROM TAB_COLUMNS
10 Online Recent posts Share Join Chat

6 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

WHERE VERSION = 100)

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Most Efficient: Code:

SELECT TAB_NAME FROM TABLES WHERE (TAB_NAME, DB_VER) = (SELECT TAB_NAME, DB_VER FROM TAB_COLUMNS WHERE VERSION = 100)

Multi-column UPDATE example Least Efficient:

Code:
UPDATE EMP SET EMP_CAT = (SELECT MAX(CATEGORY) FROM EMP_CATEGORIES), SAL_RANGE = (SELECT MAX(SAL_RANGE) FROM EMP_CATEGORIES ) WHERE EMP_DEPT = 200;

Most Efficient: Code:

UPDATE EMP SET (EMP_CAT, SAL_RANGE) = (SELECT MAX(CATEGORY), MAX(SAL_RANGE) FROM EMP_CATEGORIES) WHERE EMP_DEPT = 200;

13)

Use Table Aliases

Always use table aliases and prefix all column names by their aliases where there is more than one table involved in a query. This will reduce parse time and prevent syntax errors from occurring when ambiguously named columns are added later on. 14)

Use EXISTS in Place of IN for Base Tables

Many base table queries have to actually join with another table to satisfy a selection criteria. In such cases, the EXISTS (or NOT EXISTS) clause is often a better choice for performance. e.g. Least Efficient: Code:
SELECT * FROM EMP (Base Table) WHERE EMPNO > 0 AND DEPTNO IN (SELECT DEPTNO FROM DEPT WHERE LOC = DELHI)

10 Online

Recent posts

Share

Join Chat

7 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Most Efficient: Code:

SELECT * FROM EMP WHERE EMPNO > 0 AND EXISTS (SELECT X FROM DEPT WHERE DEPTNO = EMP.DEPTNO AND LOC = DELHI).

15)

Use NOT EXISTS in Place of NOT IN

In sub-query statements such as the following, the NOT IN clause causes an internal sort/merge. The NOT IN clause is the all-time slowest test, because it forces a full read of the table in the sub-query SELECT. Avoid using NOT IN clause either by replacing it with Outer Joins or with NOT EXISTS clause as shown below: Code:
SELECT . . . FROM EMP WHERE DEPT_NO NOT IN (SELECT DEPT_NO FROM DEPT WHERE DEPT_CAT = A);

To improve the performance, replace this code with: Method 1 (Efficient): Code:
SELECT . . . FROM EMP A, DEPT B WHERE A.DEPT_NO = B.DEPT_NO (+) AND B.DEPT_NO IS NULL AND B.DEPT_CAT(+) = 'A';

Method 2 (Most Efficient): Code:

SELECT . . . FROM EMP E WHERE NOT EXISTS (SELECT X FROM DEPT WHERE DEPT_NO = E.DEPT_NO AND DEPT_CAT = A);

16)

Use Joins in Place of EXISTS

In general join tables rather than specifying sub-queries for them such as the following: Code:
SELECT ENAME FROM EMP E WHERE EXISTS (SELECT X FROM DEPT
10 Online Recent posts Share Join Chat

8 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

WHERE DEPT_NO = E.DEPT_NO AND DEPT_CAT = A);

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

To improve the performance, specify: Code:

SELECT ENAME FROM DEPT D, EMP E WHERE E.DEPT_NO = D.DEPT_NO AND D.DEPT_CAT = A;

17)

Use EXISTS in Place of DISTINCT

Try to avoid joins that require the DISTINCT qualifier on the SELECT list when we submit queries used to determine information at the owner end of a one-to-many relationship (e.g. departments that have many employees). e.g. Least Efficient: Code:
SELECT DISTINCT DEPT_NO, DEPT_NAME FROM DEPT D, EMP E WHERE D.DEPT_NO = E.DEPT_NO

Most Efficient: Code:

SELECT DEPT_NO, DEPT_NAME FROM DEPT D WHERE EXISTS (SELECT X FROM EMP E WHERE E.DEPT_NO = D.DEPT_NO);

EXISTS is a faster alternative because the RDBMS kernel realizes that when the sub-query has been satisfied once, the query can be terminated. 18)

Identify "Poorly Performing" SQL statements

Use the following queries to identify the poorly performing SQL statements. Code:
SELECT EXECUTIONS, DISK_READS, BUFFER_GETS, ROUND((BUFFER_GETS-DISK_READS)/BUFFER_GETS,2) Hit_Ratio, ROUND(DISK_READS/EXECUTIONS,2) Reads_Per_Run, SQL_TEXT FROM V$SQLAREA WHERE EXECUTIONS > 0 AND BUFFER_GETS > 0 AND (BUFFER_GETS - DISK_READS) / BUFFER_GETS < 0.80 ORDER BY 4 DESC;

19)
10 Online Recent posts Share Join Chat

9 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Use Indexes to Improve Performance

An index is a conceptual part of a database table that may be used to speed up the retrieval of data from that table. Internally, ORACLE uses a sophisticated self-balancing B-tree index structure. Indexed retrieval of data from a database is almost always faster than a full table scan. The ORACLE optimizer uses the indexes defined for a table when it figures out the most efficient retrieval path for a query or update statement. ORACLE also uses indexes in performing more efficient joins of multiple tables. Another benefit of indexes is that they provide a way to guarantee the uniqueness of the primary key in a table. You can index any column in a table except those defined with data types of LONG or LONG RAW. In general, indexes are most useful when they are specified on large tables. If small tables are frequently joined, however, youll find that performance improves when you index these tables too. Although indexes usually provide performance gains, there is a cost to using them. Indexes require storage space. They also require maintenance. Every time a record is added to or deleted from a table and every time an indexed column is modified, the index(es) itself must be updated as well. This can mean 4 or 5 extra disk I/Os per INSERT, DELETE or UPDATE for a record. Because indexes incur the overhead of data storage & processing, you can actually degrade response time if you specify indexes that you dont use. The maximum number of indexes is usually between 4 & 6 per table. Do keep the number of indexes over a single table to a minimum, but if an index is useful and response times can be kept below the agreed-upon limit for your site, then dont hesitate to create the index. 20)

Avoid Calculations on Indexed Columns

If the indexed column is a part of a function (in the WHERE clause), the optimizer does not use an index and will perform a full-table scan instead. Note: The SQL functions MIN & MAX are exceptions to this rule and will utilize all available indexes. e.g. Least Efficient: Code:
SELECT . . . FROM DEPT WHERE SAL * 12 > 25000;

Most Efficient: Code:

SELECT . . . FROM DEPT WHERE SAL > 25000 / 12.

21)

Avoid NOT on Indexed Columns

In general, avoid using NOT when testing indexed columns. The NOT function has the same effect on indexed columns that functions do. When ORACLE encounters a NOT, it will choose not to use the index & will perform a full-table scan instead. e.g.
10 Online Recent posts Share Join Chat

10 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Least Efficient : (Here, index will not be used) Code:

SELECT . . . FROM DEPT WHERE DEPT_CODE NOT = 0;

Most Efficient : (Here, index will be used) Code:

SELECT . . . FROM DEPT WHERE DEPT_CODE > 0; In a few cases, the ORACLE optimizer will automatically transform NOTs (when they ar NOT > to <= NOT >= to < NOT < to >= NOT <= to >.

22)

Use UNION in Place of OR (in case of Indexed Columns)

In general, always use UNION instead of OR in WHERE clause. Using OR on an indexed column causes the optimizer to perform a full-table scan rather than an indexed retrieval. Note, however, that choosing UNION over OR will be effective only if both columns are indexed; if either column is not indexed, we may actually increase overheads by not choosing OR. In the following example, both LOC_ID & REGION are indexed. Specify the following: Code:
SELECT LOC_ID, FROM LOCATION WHERE LOC_ID = UNION SELECT LOC_ID, FROM LOCATION WHERE REGION = LOC_DESC, REGION 100 LOC_DESC, REGION DELHI

instead of Code:
SELECT LOC_ID, LOC_DESC, REGION FROM LOCATION WHERE LOC_ID = 100 OR REGION = DELHI

23)

Usage of the Wheres

Some SELECT statement WHERE clauses do not use indexes at all. Some of the examples are shown below: In the following example, the != function cannot use an index. Remember, indexes can tell you what is in a table, but not what is not in a table. All references to NOT, != and <> disable index usage: Do Not Use:
10 Online

Code:

Recent posts

Share

Join Chat

11 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

SELECT ACCOUNT_NAME FROM TRANSACTION WHERE AMOUNT != 0;

Use: Code:
SELECT ACCOUNT_NAME FROM TRANSACTION WHERE AMOUNT > 0;

In the following example, || is the concatenate function. It, like other functions, disables indexes. Do Not Use: Code:
SELECT ACCOUNT_NAME, AMOUNT FROM TRANSACTION WHERE ACCOUNT_NAME || ACCOUNT_TYPE = AMEXA;

Use: Code:
SELECT ACCOUNT_NAME, AMOUNT FROM TRANSACTION WHERE ACCOUNT_NAME = AMEX AND ACCOUNT_TYPE = A

24)

GROUP BY & Predicate Clauses

The performance of GROUP BY queries can be improved by eliminating unwanted rows early in the selection process. The following two queries return the same data. However, the second is potentially quicker, since rows will be eliminated before the set operators are applied. e.g. Least Efficient: Code:
SELECT JOB, AVG(SAL) FROM EMP GROUP BY JOB HAVING JOB = PREDIDENT OR JOB = MANAGER

Most Efficient: Code:

SELECT JOB, AVG(SAL) FROM EMP WHERE JOB = PREDIDENT OR JOB = MANAGER GROUP BY JOB

10 Online

Recent posts

Share

Join Chat

12 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Reliant Energy Reliant solar panel leasing is a great option for renewable energy! www.reliant.com/solar 1. Fast Database Response It's Reason 1 of 6 To Change To IBM DB2. Get All 6 In Your Free eBook. www.IBM.com/facts Database Security Guide Practical Guide to Database Security & Compliance. Free Copy! www.mcafee.com
Categories: Oracle Tags : sql

Ads by Google Ads by Google Ads by Google

Sql Ms sql queries Sql keyword search

Sql query tutorial Inner joins sql Format sql statement

Oracle pl sql Syntax for sql Sql union example

Sql server database Dynamic sql performance Sql insert into

Find us on Facebook

TechForum4U
Like 46 people like TechForum4U.

Sangita

Nihar

Sonam

Deepak

Chandan

Gunasekar

Anu

Eidrian

Vicky

Fharhan

Harsh

Twana

Manish

Suresh

Angad

Twum

Pankaj

Zsanett

Arale

Prayag

Ryan Joseph

Sudipa

Linda

Ven

Sujeet

Harsha

Facebook social plugin

Introduction To CSS (Cascading Style

10 Online Recent posts Share

programs. Although these...

Join Chat

13 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

Tags: operating system deallock 10 Online Recent posts Share

Join Chat

14 of 15

9/8/2011 9:45 AM

How To Write Efficient SQL?

http://techforum4u.com/content.php/323-How-To-Write-Efficie...

All times are GMT. The time now is 04:21 PM. Content Copyright of Users, Anything Else TechForum4U. All rights reserved. Powered by vBulletin Version 4.0.7 Copyright 2011 vBulletin Solutions, Inc. All rights reserved.

10 Online

Recent posts

Share

Join Chat

15 of 15

9/8/2011 9:45 AM