How to Troubleshoot & Optimize Database Query Performance for Your Application According to the recent DZone Performance Guide, “database performance problems are the most challenging to fix” with manual firefighting and lack of actionable insights being the top monitoring challenges. When these three issues converge on your application delivery chain it can mean a long time and a lot of effort to find and fix critical issues. Is it really your database that's slow? Or is it the way your OR-Mapper or code accesses the database? A misconfigured connection pool on one of your servers? Or a missing table index, a full tablespace, or simply an I/O issue? In this webinar we show you how Dynatrace AppMon extends traditional APM through its new Database Agent, providing a view that both Developers and DBAs can trust and use to identify: • Problematic SQL Queries, unprepared statements or misconfigured connection pools • Performance impacting database sessions, slow queries, waits and locks on your database instances • Optimizations by looking at the Execution Plans of your application-specific SQL queries • Query patterns like n+1 being implemented in your application Eliminate wasted cycles by bridging the Dev-DBA collaboration gap with a consistent view based on app-focused database access metrics, database instance system and performance metrics, and execution plans for your critical SQL queries. Buck the trends that DZone is seeing! Get tips you can use right away.

1. Confidential, Dynatrace, LLC
Asad Ali
Director, Product Specialist
@AsadThoughts
Dynatrace
How to Troubleshoot
& Optimize Database Query
Performance for Your Application

3. Let the blame game start!
Web Server Application Server Database
DEV Team DBA Team
Blame the database for
all performance issues
Blame the SW/HW or
system administrators
Network?

4. Database Heavy:
66.51% (40.27s)
Time Spent in SQL Execs

6. Excessive SQL: 24889!
Calls to Database
Database Heavy:
66.51% (40.27s)
Time Spent in SQL Execs

7. Database
Performance
hotspots
Application Design
DB Design DB Queries
Server/Infrastructure

8. Database Performance Hotspots
Application Design Database Infrastructure
Application

9. of database
performance issues
can be solved by developers70%

10. Database Performance Hotspots
• Lack of use of bind values
• Too many SQL statements per user action
• Database server overloaded
• DB connection pool monitoring

11. Example 1:
performance tuning by
using bind variables

12. Oracle SQL Cache
<?php
$db = new PDO('oci:dbname=sid', 'username', 'password');
$data = Array();
$data[] = $db->query("select * from country where code = 'AT'");
$data[] = $db->query("select * from country where code = 'AU'");
$data[] = $db->query("select * from country where code = 'NZ'");
$data[] = $db->query("select * from country where code = 'ES'");
?>

13. Query Plan Evaluation

15. MSSQL Cache

16. MSSQL Cache

17. Little Bobby Tables
addStudentInfo(String lname, String fname) {
String query = “insert into Student(last_name, first_name)
values (‘”+lname + ”’, ‘” + fname + “’)”;
}
Normal Operation:
First Name: Asad
Last Name : Ali
insert into Student (‘Ali’, ‘Asad’)
Malicious Operation:
First Name: Asad’); Drop table Student;
Last Name : Ali
insert into Student (‘Ali’, ‘Asad’); Drop table
Student

18. Little Bobby Tables

19. Oracle SQL Cache
<?php
$db = new PDO('oci:dbname=sid', 'username', 'password');
$data = Array();
$ps = $db->prepare("select * from country where code = :code");
$data[] = $ps->execute(array("code" => "AT"));
$data[] = $ps->execute(array("code" => "AU"));
$data[] = $ps->execute(array("code" => "NZ"));
$data[] = $ps->execute(array("code" => "ES"));
?>

21. Example 2:
application performing
too many SQL statements

22. Excessive SQL: 24889!
Calls to Database
Database Heavy:
66.51% (40.27s)
Time Spent in SQL Execs

23. Why are there so many SQL statements?
$schools = new SchoolEntities();
foreach ($schools as $school) {
foreach ($school->departments as $department) {
foreach ($department->courses as $course) {
echo $department->name . ": " . $course->title);
}
}
}

24. N+1 problem
• 10 schools
• 20 departments per school
• 50 courses per department
=> 10 x 20 x 50 = 10001 single database statements !!!

25. Retrieving too many records
$schools = new SchoolEntities();
foreach ($schools->departments as $department) {
foreach ($department->courses as $course) {
if ($course->category == "SQL" &&
$course->level == "expert")) {
echo $department->name . ": " . $course->title);
}
}
}
=> 3 records, still 10001 queries

26. Solution: use a JOIN query with a WHERE clause
$rows = $db->query ("
select department.name as department, course.title as course
from school
join department on school_id = school.id
join course on department_id = department.id
where course.category = 'SQL' and course.level = 'expert'
");
foreach ($rows as $row) {
echo $department . ": " . $course);
}
=> ONE database statement !!!

27. Example 3:
overloaded database server

28. Major database performance problem

32. Example 4:
database connection pool settings

33. Database Connection Pool

34. Database Connection Pool

35. Database Connection Pool

36. Auto DB Pattern Detection

37. Live Demo

38. Q & A
@AsadThoughts

39. Performance Tuning – best practices
• Use bind variables to leverage SQL caching
• Use join queries to avoid N+1 problems
• Avoid index killers in queries
• Use stored procedures for complex functionality
• Leverage connection pooling
• Watch for other processes / application on your database
http://apmblog.dynatrace.com/2016/05/23/improve-oracle-database-performance-using-bind-variables/
https://www.infoq.com/articles/Diagnose-Microservice-Performance-Anti-Patterns