Managing workloads and optimizing queries are essential
tasks for maximizing the performance of a Db2 databases and the applications that access them. By employing
effective techniques, DBAs and performance analysts can streamline query execution,
reduce resource contention, and enhance overall system efficiency.
The application code itself must be designed appropriately and monitored for efficiency. In fact, many experts agree that as much as 70 to 80 percent of performance problems are caused by improperly coded database applications. SQL is the primary culprit. Coding efficient SQL statements can be complicated. Developers need to be taught how to properly formulate SQL statements and SQL statements must be constantly monitored and tuned.
Query Rewriting
One technique for workload management and query optimization
is query rewriting. Query rewriting involves modifying the structure or logic
of a query to achieve better performance. This can include simplifying complex
expressions, reordering join operations, or breaking down a single complex
query into multiple simpler queries. By understanding the underlying data model
and query requirements, you can rewrite queries to optimize
execution plans and improve overall performance.
With that in mind, it is important to understand that Db2 itself can perform query rewrite as part of the optimization process. The query compiler can rewrite SQL and XQuery statements into different forms to improve optimization.
Of course, you (as a developer or tuner) can still make changes to SQL to try to influence the optimizer to achieve different (and hopefully better) access paths.
SQL, by its very nature, is quite flexible. It uses a free-form structure that gives the user the ability to develop SQL statements in a way best suited to each user. Each SQL request is parsed by Db2 during compilation and optimization before it is executed to check for proper syntax and to optimize the request.
Therefore, SQL statements do not need to start in any given column and can be strung together on one line or broken apart on several lines. Any SQL request could beformulated in a number of different but functionally equivalent ways. SQL’s flexibility makes it intrinsically simple, but flexibility can complicate performance management because different but equivalent SQL formulations can result in variable performance.
When you are writing your SQL statements to access Db2 data, keep in mind that you should look at various different ways to formulate the same query to see which one performs best. For example, you might change a BETWEEN predicate to two predicates using <= and >=. This is one simple example and many different things can change an access path, so be creative and test different ways of using SQL to request the same data.
Use EXPLAIN to Examine Access Paths
Programmers need to be schooled in the practice of examining SQL access paths. Using EXPLAIN and querying the resutls allows developers to request information on how the optimizer will satisfy each query. Will an index be used? In what order will the tables be joined? Will the query be broken up into parallel tasks or not?
Of course, you may want to use a Visual Explain tool to look at access paths visually instead of querying complex and sometimes arcane data in plan tables. For example, IBM Data Studio offers a Visual Explain capability (as do other tools).
A few guidelines to consider:
- Always bind every production program using EXPLAIN YES. This will ensure that the access path details are externalized if/when you need to review them should performance issues arise.
- Ensure that application developers understand EXPLAIN and have access to plan table data when testing new code. Catching problematic access paths in test is clearly better than waiting for the problems to surface in production.
- Make sure that all Db2 developers have access to tools for reviewing and examining access paths and explain information (e.g. Data Studio).
Fundamental SQL Guidelines
These and many other factors influence the efficiency of SQL. Not all application problems are due to improperly coded SQL. The host language application code in which the SQL has been embedded also can be inefficient, causing database application performance to suffer.
These are, however, three simple but important rules to follow when writing your SQL statements for performance. Of course, SQL performance is a complex topic and to understand every nuance of how SQL performs can take alifetime. That said, adhering to the following simple rules puts you on the right track to achieving high-performing Db2 applications.
First, always provide only the exact columns that you need to retrieve in the SELECT-list of each SQL SELECT statement. A common way of stating this is “do not use SELECT *”. The shorthand SELECT * means retrieve all columns from the table(s) being accessed. Using SELECT * may be fine for quick and dirty queries but it is a bad practice for inclusion in application programs because:
- Db2 tables may need to be changed in the future to
include additional columns. SELECT * in production programs will retrieve
those new columns, too, and your program may not be capable of handling
the additional data without requiring time-consuming changes.
- Db2 consumes additional resources for every column
that is requested to be returned. If the program does not need the data,
it should not ask for it. Even if the program needs every column, it is
better to explicitly ask for each column by name in the SQL statement for
clarity and to avoid the previous pitfall.
Secondly, do not ask for what you already know. This may sound simplistic, but most programmers violate this rule at one time or another. For example,consider what is wrong with this simple query:
SELECT LASTNAME, FIRST_NAME, JOB_CODE, DEPTNO
FROM EMP
WHERE JOB_CODE = 'A'
AND DEPTNO = 'D01';
Look at the SELECT-list. There are four columns specified but only two of them are needed. We know that JOB_CODE will always be A and DEPTNO will always be D01 because we told Db2 to only return those rows using the WHERE clauses. So do not ask Db2 to return that data... you already know it!
Every column that Db2 must and return to the program adds overhead. It may be a small amount of overhead, but if this statement runs many times during the day (hundreds, or even thousands, of times), that small overhead adds up to significant overhead.
And thirdly, use the WHERE clause to filter data in the SQL instead of bringing it all into your program to filter. This too is a common rookie mistake. It is much better for Db2 to filter the data before returning it to your program. This is so because Db2 requires additional I/O and CPU resources to obtain each row of data. The fewer rows passed to your program, the more efficient your SQL will be.
Query Hints and Tweaking
The use of query hints is another approach to query
optimization. Hints provide directives to the optimizer on how to execute a
specific query, influencing the choice of access paths, join strategies, or
join orders. By carefully selecting and applying query hints, you can guide the optimizer's decisions and ensure optimal query
execution plans. There are three types of hints:
- One type of hint is to modify the query in some way to encourage (or force) the optimizer to choose a different access path. This is often called tweaking the SQL. For example, you might choose to append OR 0 = 1 to a predicate to cause Db2 to avoid using an index.
- A second type of hint is to give the optimizer quidance as to the number of rows that will be returned using OPTIMIZE FOR n ROWS. In that case, instead of using the database statistics it will use the guidance you provide.
- Another type of hint, which is much better, is to explicitly use the hint capabilities of Db2 to force a particular query to use a specific, pre-determined access path.
In any case, it is important to use hints judiciously, as
excessive or unnecessary hints may hinder the optimizer's ability to adapt to
changing data or system conditions.
Additional Techniques and Tools
As part of ensuring an optimal SQL environment it is important that DBAs first setup an effective environment that is properly implemented and administered. This includes establishing standard methods for appropriate indexing, regular statistics collection, and setting database configuration parameters approrpriately to optimize query performance.
Perhaps the most important thing you can do to assure optimal performance of
your database applications is to create the correct indexes for your tables. Indexing appropriately on frequently queried columns can significantly improve query execution times. Regularly collecting and updating statistics ensures that the optimizer has accurate information to make informed decisions. Optimizing database configuration parameters, such as query parallelism or memory settings, can also have a significant impact on workload management and query performance.
Managing the
performance of your database applications requires in-depth monitoring. Be sure
to allocate an appropriate budget to acquire performance management tools to
ensure the efficiency of your database systems.
Query optimization tools are valuable assets for managing workloads and improving query performance. These tools provide insights into query execution plans, access paths, and performance statistics. They allow database administrators to analyze query performance, identify potential bottlenecks, and make informed decisions for optimization.
Moreover, workload management techniques such as query
prioritization, resource allocation, and concurrency control contribute to
efficient query execution. Prioritizing critical queries, allocating resources
based on workload importance, and managing concurrency effectively help ensure
that high-priority queries receive the necessary resources and are processed
efficiently.
Summing Things Up
In conclusion, managing workloads and optimizing queries are
crucial aspects of maximizing the performance of your Db2 database and applications. Techniques
such as applying fundamentail query development methods, query rewriting, the use of hints, and leveraging query optimization
tools can significantly enhance query performance. Additionally, employing
indexing strategies, collecting accurate statistics, and configuring database
parameters contribute to efficient workload management. By implementing these
techniques, DBAs, develoeprs, and performance analysts can streamline query execution, improve
system responsiveness, and achieve optimal performance in their Db2
environments.
