MySQL 8
Tips and Tricks
Dave Stokes
@stoker
david.stokes@oracle.com
Elephantdolphin.blogger.com
OpensourceDBA.wordpress.com
What This Talk Is About??
2
MySQL 8 Features
This is not a simple talk on performance tuning a database or a cookbook
where you set X to Y and get Z percent better performance.
Instead this a talk about developments that have the potential to make big
changes in the way you use MySQL Instances.
3
Simple Answer:
Set
INNODB_BUFFER_POOL_SIZE
To ~ 80% of RAM
4
Quick check on your buffer pool setting:
mysql> SELECT
@@innodb_buffer_pool_size/1024/1024/1024;
5
Simple answers are great if
… you only live in a
simple world!
6
7
Quiet Database Revolution
Cloud
NoSQL
Security
Self-tuning 8
1. Upgrade
9
Minor Interruption
Please excuse
this small rant
about help
forums!
10
Hi!
I know nothing about brain surgery but ….
I popped the top of the skull off my coworker in an attempt to adjust their attitudes.
How do I do make those adjustments?
And what is the red stuff leaking on the carpet?
I have an Ikea allen wrench, a screwdriver, and some duct tape!
Please advise ASAP as the coworker is vital to production.
And how do you clean a carpet??
Many questions on sites like Quora.com and Stackoverflow.com are … frustrating 11
End of Rant
12
Big Changes Behind the Scenes
https://stackoverflow.com/questions/50505236/mysql-8-0-group-by-performance
To compare MySQL 5.7 and 8.0 I created a table using sysbench. And I tried the test. The performance of the server is exactly
the same As a result, oltp_point_select showed almost similar performance.
However, when doing the group by tests below, MySQL 8.0 showed 10 times better performance.
But I do not know why it is fast.
I do not know if I can find the MySQL 8.0 Release Notes. In 8.0, who will tell me why group by are faster?
13
Oystein Answers
MySQL 8.0 uses a new storage engine, TempTable, for internal temporary tables. (See MySQL Manual
for details.) This engine does not have a max memory limit per table, but a common memory pool for
all internal tables. It also has its own overflow to disk mechanism, and does not overflow to InnoDB or
MyISAM as earlier versions.
The profile for 5.7 contains "converting HEAP to ondisk". This means that the table reached the max
table size for the MEMORY engine (default 16 MB) and the data is transferred to InnoDB. Most of the
time after that is spent accessing the temporary table in InnoDB. In MySQL 8.0, the default size of the
memory pool for temporary tables is 1 GB, so there will probably not be any overflow to disk in that
case.
14
Please Upgrade
Besides the
obvious security
and bug updates
there are some
major
improvements
waiting for you in
MySQL 8
15
2. Data Dictionary
16
Metadata before 8
MySQL Server incorporates a transactional data dictionary that stores
information about database objects. In previous MySQL releases, dictionary
data was stored in metadata files, non transactional tables, and storage
engine-specific data dictionaries.
Metadata was kept in a series of files --- eatinging up inodes, getting damaged
or deleted at the wrong time, and hard to fix
17
Data Dictionary
Benefits of the MySQL data dictionary include:
● Simplicity of a centralized data dictionary schema that uniformly stores dictionary data.
● Removal of file-based metadata storage.
● Transactional, crash-safe storage of dictionary data. Uniform and centralized caching for
dictionary objects. A simpler and improved implementation for some
INFORMATION_SCHEMA tables.
● Atomic DDL.
18
Big Change
Good news: You can Bad news: You can
now have millions of now have millions of
tables within a tables within a
schema schema
19
Instant Add Column
This INSTANT ADD COLUMN patch was contributed by the Tencent Games
DBA Team. We would like to thank and acknowledge this important and timely
contribution by Tencent Games.
20
Bye Bye Bug #199
No more Innodb auto_increment stats loss
21
3. CATS
22
Contention Aware Transaction Schedule
https://arxiv.org/pdf/1602.01871.pdf
Identifying the Major Sources of Variance in Transaction Latencies: Towards More Predictable
Databases -- University of Michigan
The CATS algorithm is based on a simple intuition: not all transactions are equal, and not all objects
are equal. When a transaction already has a lock on many popular objects, it should get priority
when it requests a new lock. In other words, unblocking such a transaction will indirectly contribute
to unblocking many more transactions in the system, which means higher throughput and lower
latency overall.
23
Indexes Versus Histograms
Indexes are great but have a cost at insert update, delete,
and at statistic gathering time.
Histograms can be run after major changes to data or at
slack times.
24
Histograms
The query optimizer needs statistics to create
a query plan.
■ How many rows are there in each table?
■ How many distinct values are there in each column?
■ How is the data distributed in each column?
25
What is a Histogram?
26
What is a Histogram?
A histogram is an approximation of the data distribution for a column. It can tell you
with a reasonably accuray whether your data is skewed or not, which in turn will
help the database server understand the nature of data it contains.
MySQL has chosen to support two different types: The “singleton” histogram and
the “equi-height” histogram. Common for all histogram types is that they split the
data set into a set of “buckets”, and MySQL automatically divides the values into
buckets, and will also automatically decide what type of histogram to create.
27
Syntax
ANALYZE TABLE tbl_name
UPDATE HISTOGRAM ON col_name [, col_name]
WITH N BUCKETS;
ANALYZE TABLE tbl_name DROP HISTOGRAM ON col_name [, col_name];
28
4. Invisible Indexes
29
What is an Invisible Index?
Indexes can be marked as ‘invisible’ to the optimizer
Use EXPLAIN to see query plan and tell if index aids or
hinders query
ALTER TABLE t1 ALTER INDEX i_idx INVISIBLE;
ALTER TABLE t1 ALTER INDEX i_idx VISIBLE;
30
5. Replacing
Many-to-many
joins with JSON
31
Relational Database + JSON Fields (hybrid)
Leverage power of RDMS but augmented with JSON fields
● Use JSON to eliminate one of the issues of traditional relational databases
-- the many-to-many join
● Allows more freedom to store unstructured data (data with pieces
missing)
● You can still use SQL to work with the data via a database connector but
the JSON documents can be manipulated directly in code
32
JSON Document Tips
● Minimize joins - reducing how many joins you need can speed up queries.
Faster access over data denormalization
● Plan for mutability - Schema-less design are based mutability. Build your
applications with the ability to change the document as needed (and within
reason)
● Use embedded arrays and lists to store relationship among documents
○ This can be as simple as embedding the data in document or embedding an array of
document ids in the document. In the first case the data is available when you read the
document. In the second, it takes only one more step to get the data.
○ In cases of seldom read (used) relationships the array of ids is more efficient as there is
less data to read on the first pass 33
Quick Example
Customer table -- ID Customer table -- ID
Address -- Address1 .. n JSON docs -- Address, Phone, Payment
Phone -- Phone1..n
Payment -- Bank1...n
4 or more reads to process an order
1 read
34
6. Resource Groups
35
Resource Groups
MySQL supports creation and management of resource groups, and permits
assigning threads running within the server to particular groups so that threads
execute according to the resources available to the group.
Group attributes enable control over its resources, to enable or restrict resource
consumption by threads in the group. DBAs can modify these attributes as
appropriate for different workloads.
36
Resource Groups
Currently, CPU time is a manageable resource, represented by the concept of
“virtual CPU” as a term that includes CPU cores, hyperthreads, hardware threads,
and so forth.
The server determines at startup how many virtual CPUs are available, and
database administrators with appropriate privileges can associate these CPUs with
resource groups and assign threads to groups.
37
Create a Resource Group
CREATE RESOURCE GROUP Batch
TYPE = USER
VCPU = 2-3 -- assumes a system with at least 4 CPUs
THREAD_PRIORITY = 10;
38
Using a Resource Group
INSERT /*+ RESOURCE_GROUP(Batch) */ INTO t2 VALUES(2);
39
9. Autonomy
40
Self Tuning
Databases
Databases are getting
better at realizing their
environments (cores,
disks, busses, virtual,
container, buffers), loads,
query patterns, and
networks.
You will see much more
of this much sooner than
you would expect.
41
The Payoff is less ...
Human Labor
Human Error
No Manual Labor 42
10. JSON Updates
43
JSON Data Type Extremely Popular
Introduced in MySQL 5.7, the JSON data type provides a
1GB document store in a column of a row in a table.
Over thirty functions to support JSON data types
The foundation on the MySQL Document Store, a NoSQL
JSON document store
44
Inplace Update of JSON columns
In MySQL 8.0, the optimizer can perform a partial, in-place
update of a JSON column instead of removing the old
document and writing the new document in its entirety to
the column.
45
New JSON Functions
JSON_PRETTY
JSON array and object aggregations
JSON_SIZE and JSON_FREE
Change in JSON_MERGE : JSON_MERGE_PRESERVE and JSON_MERGE_PATCH
46
The JSON Functions
Name Description
JSON_ARRAY() Create JSON array
JSON_ARRAY_APPEND() Append data to JSON document
JSON_ARRAY_INSERT() Insert into JSON array
-> Return value from JSON column after evaluating path; equivalent to JSON_EXTRACT().
JSON_CONTAINS() Whether JSON document contains specific object at path
JSON_CONTAINS_PATH() Whether JSON document contains any data at path
JSON_DEPTH() Maximum depth of JSON document
JSON_EXTRACT() Return data from JSON document
->> Return value from JSON column after evaluating path and unquoting the result; equivalent to JSON_UNQUOTE(JSON_EXTRACT()).
JSON_INSERT() Insert data into JSON document
JSON_KEYS() Array of keys from JSON document
JSON_LENGTH() Number of elements in JSON document
JSON_MERGE() (deprecated 8.0.3) Merge JSON documents, preserving duplicate keys. Deprecated synonym for JSON_MERGE_PRESERVE()
JSON_MERGE_PATCH() Merge JSON documents, replacing values of duplicate keys
JSON_MERGE_PRESERVE() Merge JSON documents, preserving duplicate keys
JSON_OBJECT() Create JSON object
JSON_PRETTY() Prints a JSON document in human-readable format, with each array element or object member printed on a new line, indented two spaces with respect to its parent.
JSON_QUOTE() Quote JSON document
JSON_REMOVE() Remove data from JSON document
JSON_REPLACE() Replace values in JSON document
JSON_SEARCH() Path to value within JSON document
JSON_SET() Insert data into JSON document
JSON_STORAGE_FREE() Freed space within binary representation of a JSON column value following a partial update
JSON_STORAGE_SIZE() Space used for storage of binary representation of a JSON document; for a JSON column, the space used when the document was inserted, prior to any partial updates
JSON_TABLE() Returns data from a JSON expression as a relational table
JSON_TYPE() Type of JSON value
JSON_UNQUOTE() Unquote JSON value
JSON_VALID() Whether JSON value is valid
47
JSON_TABLE
JSON_TABLE takes schema-less JSON documents and
turn it into a temporary relational table that can be
processed like any other relational table.
48
mysql> select country_name,
IndyYear
from countryinfo,
json_table(doc,"$" columns
(country_name char(20) path "$.Name",
IndyYear int path "$.IndepYear"))
as stuff
where IndyYear > 1992;
+----------------+----------+
| country_name | IndyYear |
+----------------+----------+
| Czech Republic | 1993 |
| Eritrea | 1993 |
| Palau | 1994 |
| Slovakia | 1993 |
+----------------+----------+
JSON_TABLE Example 49
mysql> select country_name,
IndyYear
from countryinfo,
json_table(doc,"$" columns
(country_name char(20) path "$.Name",
IndyYear int path "$.IndepYear"))
as stuff
where IndyYear > 1992;
+----------------+----------+
| country_name | IndyYear |
+----------------+----------+
| Czech Republic | 1993 |
| Eritrea | 1993 |
| Palau | 1994 |
| Slovakia | 1993 |
+----------------+----------+
JSON_TABLE Example 50
12. Sys Schema
51
What is in the SYS Schema
MySQL 8.0 includes the sys schema, a set of objects that helps DBAs and developers
interpret data collected by the Performance Schema. sys schema objects can be used
for typical tuning and diagnosis use cases. Objects in this schema include:
● Views that summarize Performance Schema data into more easily
understandable form.
● Stored procedures that perform operations such as Performance Schema
configuration and generating diagnostic reports.
● Stored functions that query Performance Schema configuration and provide
formatting services.
52
Top 5 Runtime 53
Full Table Scans 54
TOP I/O 55
Stats by user 56
13. Set Persist
57
Saving Configuration Changes
SET PERSIST innodb_buffer_pool_size = 512 * 1024 * 1024;
The file mysqld-auto.cnf is created the first time a SET
PERSIST statement is executed. Further SET PERSIST
statement executions will append the contents to this file.
58
14. New Shell
59
MySQL Shell
Query tool, administration tool,
cluster manager, and supports
Python, JavaScript & SQL
60
MySQL Shell
61
MySQL Shell
62
MySQL Shell
63
MySQL Shell
Python, JavaScript & SQL modes
Management
util.checkForServerUpgrade(‘user@host.com:3306’)
dba. configureLocalInstance
dba.createCluster
64
New Protocol based on Google ProtoBuf 65
15. MySQL
Document Store
66
NoSQL or Document Store
● Schemaless
○ No schema design, no normalization, no foreign keys, no data types, …
○ Very quick initial development
● Flexible data structure
○ Embedded arrays or objects
○ Valid solution when natural data can not be modelized optimally into a
relational model
○ Objects persistence without the use of any ORM - *mapping object-oriented*
● JSON
● close to frontend
● native in JS
67
● easy to learn
{
"GNP" : 249704,
"Name" : "Belgium",
"government" : {
"GovernmentForm" :
"Constitutional Monarchy, Federation",
"HeadOfState" : "Philippe I"
},
"_id" : "BEL",
"IndepYear" : 1830,
"demographics" : {
"Population" : 10239000,
"LifeExpectancy" : 77.8000030517578
},
"geography" : {
"Region" : "Western Europe",
"SurfaceArea" : 30518,
"Continent" : "Europe"
}
}
How DBAs see data as opposed to how Developers see data 68
What if there was a way to provide both SQL
and NoSQL on one stable platform that has
proven stability on well know technology
with a large Community and a diverse
ecosystem ?
With the MySQL Document
Store, SQL is now optional!
69
★ Provides a schema flexible JSON Document Store
★ No SQL required
★ No need to define all possible attributes, tables, etc.
★ Uses new X DevAPI
★ Can leverage generated column to extract JSON values into materialized
columns that can be indexed for fast SQL searches.
★ Document can be ~1GB
○ It's a column in a row of a table
★ Allows use of modern programming styles
○ No more embedded strings of SQL in your code
○ Easy to read
★ Also works with relational Tables
★ Proven MySQL Technology
Built on the MySQL JSON Data type and Proven MySQL Server Technology 70
★ Connectors for
○ C++, Java, .Net, Node.js, Python, PHP
○ working with Communities to help them supporting it too
★ New MySQL Shell
○ Command Completion
○ Python, JavaScripts & SQL modes
○ Admin functions
○ New Util object
○ A new high-level session concept that can scale from single MySQL
Server to a multiple server environment
★ Non-blocking, asynchronous calls follow common language patterns
★ Supports CRUD operations
71
Starting using MySQL in few seconds 72
Migration from MongoDB
to MySQL Document Store
For this example, I will use the well known restaurants
collection:
We need to dump the data to a file and
we will use the MySQL Shell
with the Python interpreter to load the data.
73
Dump and load using MySQL Shell & Python
This example is inspired by @datacharmer's work: https://www.slideshare.net/datacharmer/mysql-documentstore
$ mongo quiet eval 'DBQuery.shellBatchSize=30000;
db.restaurants.find().shellPrint()' \
| perl -pe 's/(?:ObjectId|ISODate)\(("[^"]+")\)/ $1/g' > all_recs.json
74
75
Let’s query
Too many records to show here … let’s limit it!
76
More Examples! 77
Let’s add a selection criteria 78
> db.restaurants.find({"cuisine": "French",
"borough": { $not: /^Manhattan/} }, Syntax is slightly
{"_id":0, "name":> 1,"cuisine": 1, "borough": 1}).limit(2)
{ "borough" : "Queens",
db "cuisine" : "French", different than
"name" : "La Baraka
.r Restaurant" }
{ "borough" : "Queens",
es "cuisine" : "French", MongoDB
"name" : "Air France
ta Lounge" } 79
CRUD Operations 80
Add a Document
81
Modify a Document
82
Remove a Document
83
Find a Document
84
MySQL Document Store Objects Summary
85
MySQL Document Store is Fully ACID Compliant 86
MySQL Document Store is Fully ACID Compliant 87
What about old SQL? The Hidden Part of the Iceberg 88
JSON datatype is behind the scene
★ Native datatype (since 5.7.8)
★ JSON values are stored in MySQL tables using UTF8MB4
★ Conversion from "native" SQL types to JSON values
★ JSON manipulation functions (JSON_EXTRACT,
JSON_KEYS, JSON_SEARCH, JSON_TABLES, ...)
★ Generated/virtual columns
○ Indexing JSON data
○ Foreign Keys to JSON data
○ SQL Views to JSON data 89
How Does It Work?? 90
What does a collection look like on the server ? 91
_id
Every document has a unique identifier called the document ID,
which can be thought of as the equivalent
of a table´s primary key. The document ID value can be manually
assigned when adding a document.
If novalue is assigned, a document ID is generated and assigned
to the document automatically !
Use getDocumentId() or getDocumentIds() to get _ids(s) 92
Mapping to SQL Examples
createCollection('mycollection')
mycollection.add({‘test’: 1234})(
CREATE TABLE `test`.`mycoll`
doc JSON,
INSERT INTO `test`.`mycoll` (doc) VALUES (
_id VARCHAR(32)
JSON_OBJECT('_id','663807fe367ee6114e0e5458bdac28bf',
GENERATED ALWAYS AS (doc->>'$._id') STORED
PRIMARY KEY
'test',1234));
) CHARSET utf8mb4;
93
More Mapping to SQL Examples
mycollection.find("test > 100")
SELECT doc
FROM `test`.`mycoll`
WHERE (JSON_EXTRACT(doc,'$.test') >100);
94
SQL and JSON Example 95
It's also possible to create indexes without using SQL syntax 96
SQL and JSON Example (2): validation 97
SQL and JSON Example (3): explain 98
SQL and JSON Example (3): explain 99
SQL and JSON Example (4): add index 100
SQL and JSON Example (4): add index 101
SQL and JSON Example (5): arrays 102
JSON_TABLE turns your
un-structured JSON data into a
temporary structured table!
NoSQL as SQL 103
This temporary structured table can
be treated like any other table --
LIMIT, WHERE, GROUP BY ...
NoSQL as SQL 104
More
Sophisticated
Analysis
Dig deeper into
your data for
results
105
WITH cte1 AS (SELECT doc->>"$.name" AS 'name',
doc->>"$.cuisine" AS 'cuisine',
(SELECT AVG(score) FROM
JSON_TABLE(doc, "$.grades[*]"
COLUMNS (score INT PATH "$.score")) as r ) AS avg_score
FROM restaurants)
SELECT *, rank() OVER
(PARTITION BY cuisine ORDER BY avg_score) AS `rank`
FROM cte1
ORDER by `rank`, avg_score DESC limit 10;
This query uses a Common Table Expression (CTE) and a Windowing Function to rank the
average scores of each restaurant, by each cuisine with unstructured JSON data
Find the top 10 restaurants by grade for each cuisine 106
This is the best of the two worlds in one product !
● Data integrity ● Schemaless
● ACID Compliant ● flexible data structure
● Transactions ● easy to start (CRUD)
● SQL
107
16. Locking Changes
108
SKIP LOCKED and NOWAIT
START TRANSACTION;
SELECT * FROM seats WHERE seat_no BETWEEN 2 AND 3
AND booked = 'NO'
FOR UPDATE SKIP LOCKED;
----------
SELECT seat_no
FROM seats JOIN seat_rows USING ( row_no )
WHERE seat_no IN (3,4) AND seat_rows.row_no IN (12)
AND booked = 'NO'
FOR UPDATE OF seats SKIP LOCKED
FOR SHARE OF seat_rows NOWAIT;
109
Conclusion
110
Big Changes
1. Constant Integration
2. Smarter about environment
3. More powerful SQL
4. Data Dictionary
5. NoSQL and SQL -- Best of both worlds
6. Better Command and Control
111
Please Buy My Book!!! 112
Thanks!
Contact info:
Dave Stokes
David.Stokes@Oracle.com
@Stoker
slideshare.net/davidmstokes
speakerdeck.com/davidmstokes
Elepantdolphin.blogger.com
opensourcedba.Wordpress.com
113
