├── Appendix.md
├── Chapter1.md
├── Chapter10.md
├── Chapter11.md
├── Chapter12.md
├── Chapter2.md
├── Chapter3.md
├── Chapter4.md
├── Chapter4_1.md
├── Chapter4_10.md
├── Chapter4_11.md
├── Chapter4_12.md
├── Chapter4_2.md
├── Chapter4_3.md
├── Chapter4_4.md
├── Chapter4_5.md
├── Chapter4_6.md
├── Chapter4_7.md
├── Chapter4_8.md
├── Chapter4_9.md
├── Chapter5.md
├── Chapter6.md
├── Chapter7.md
├── Chapter8.md
├── Chapter9.md
├── Part1.md
├── Part2.md
├── Part3.md
├── Part4.md
├── Part5.md
├── Preface.md
├── README.md
├── References.md
└── media
├── 068e498c1a257071ce3004ad2d7b7ee3.png
├── 08fb8a25d9542121b1e5b5ccb3cbdf6f.gif
├── 09cc60d64a306229adf9c4848d348c48.png
├── 0e32e448841daf774e632cb0884cd7f4.png
├── 12c296b6f5d91c71b24391af9c293363.png
├── 149ca62fd014bd12b60c77573a49757d.gif
├── 185beb2c6e0524d93abde3b25ecedc61.png
├── 197c7662d3b25ebbc2870a1cee917e3f.png
├── 19a92bf7065627b28a3403c000eba095.png
├── 1bb6230ef81aff3de4431206f0dbeed4.png
├── 207ecb2302928ddf7ea58a6421ded46b.png
├── 22b839631e0b6d49bc9c5810488d9336.png
├── 22ed76b816248d0b27456d03e85bcea4.png
├── 27e726f3ea50b5cabf751ee31a417b82.png
├── 28708a58742f84033b84ff551cda3b1b.gif
├── 290e969038561faf1ace6e108945b2d6.png
├── 2e14f81ddb33dc7a1db1d7f41e69dcdd.png
├── 2eba13133f9eb007d89459cce5d4055b.png
├── 3103134e2713f196cd4bd4242ef79f8e.png
├── 331f4d2fe9b0d5939e8882a770592c94.png
├── 363e8bb8f055a7611cb80e0c62b2fa2a.png
├── 3a5d10caf25003e7ea4dcace59a181f6.gif
├── 3b2c3f6b25df292e0ed14955df4a7328.png
├── 3b54c6545f0c49be73fd3afd9c6ffe79.gif
├── 3efd7f636001d03ebf6fa17c39ae43b5.png
├── 42665a7506959bdefa1b451ce564a261.png
├── 4309ffee12d2eed2548845d1e1d2e848.png
├── 440f78c946a7e68fece427a41d414a2d.gif
├── 468b1638646ec6ce6ae997ec6e52f152.png
├── 47b077e25be1755b8c698aea97f51f7f.png
├── 47c39411c3240713c75e848ef5ef4b59.png
├── 47f963cdd950abd91a459ffb66a3744e.png
├── 480170fff071f9764917821bb3a6ff6c.png
├── 48058e6b17b3f83cdc5479c38ad16648.png
├── 484244432e5e53aff18ece6ad75eb616.png
├── 4a72da4d419da7730675d64c4d060128.png
├── 4a9ca333ba0b6b18acb7572285e92c26.png
├── 4ca52ffeebc49306e76c74ed9062257d.png
├── 4cc389ee95fbae485f1e014aad393aa8.gif
├── 4daa989affba4bd90fadec0d4236343a.png
├── 4e3a6edca9e2bdafe7dd69fbdf76c8db.png
├── 4f0ea97ad117848a71148849705e311e.png
├── 4f558a475444869186a0641f934db534.gif
├── 5136495bbdfbe2cefac98d74bd36a88f.png
├── 5502725fcc5648f2f6d18aaf68832505.gif
├── 55787cfe149ebf1c574aa1da4eea678c.png
├── 56b6bb93cdc7ee8a05a1c6924f8d95c6.png
├── 5ae071ad7e34c7d0d6bc00f94811382f.png
├── 5bab13cb8c49573cfda4fcad2222fe57.png
├── 5c6f81f69eac7f61744ba3bc035b29e7.png
├── 5dc2c211205677ed7ae1528cd1911685.png
├── 612e4a7da5eea52195e8994a9b22413c.png
├── 63cf3b8bd556c6b1ce5a0436883c8f7b.png
├── 6439fb2f520bc6d99229517ca9bdbe6e.png
├── 6670e70b6d5f0f5152f643c153d13487.png
├── 66a031ab14d56289d0987c65c73323af.png
├── 67cd5a65477ae19ad1e9ec5d821e474c.png
├── 685ea4b1fb85f093764bbaa58e13347d.png
├── 68eb47a320bce3bb717a2b690da4573d.png
├── 6a6091b51c602923e5fe8b33e4422882.png
├── 6ac0aaccb67a8a3975345dd133a30e0d.png
├── 6b03a6feb6dee8e562c0970cb5417d6b.png
├── 6ce64b147aa9f2c6635b18c08715437d.png
├── 6d6657768e47e86b6522f6dd41a56ac2.png
├── 7011ddacba948b383c12628c4f81c37f.png
├── 71732b73a7cb4fe508f504fca85b0db3.png
├── 72624869e303c62430942b0c55c4897a.png
├── 739df2baa4dbff3a74a4cdc6d1d651e7.png
├── 73a26c9835141996aa0470f756f95344.png
├── 73dfb3c0a76ecd9d6faa62c025ace5e4.gif
├── 74a2f4f519d0991c114aabf3318369b2.png
├── 7759809055f85565e4bafedef312acc0.png
├── 77a84346325aa692f5e8b92741c6efb9.png
├── 77d0c0bdc5ce8574c6ad319864abb032.gif
├── 792556dcff5f267dcc5aefeb5ef0d035.png
├── 7979628d61c6921f54b584d93f88a0bf.png
├── 8276dc5ea73285406fa620d891bbc23a.png
├── 853d21533f748c1c56a4151869a82a27.gif
├── 8f9080ee71094d948ab7592b449954bb.png
├── 8fdf25878c4aff269ad26bc3002e7205.png
├── 90962de7267c4d56e20456f01796ac29.png
├── 90cde9e64d700b21ced54c3610d9a88c.png
├── 91bc13de07d658b009ae498b5afa4ac1.gif
├── 974f0f1b091afaba18ea375a73d87441.gif
├── 9a737b0274b3fad6b6d2570bba64996a.gif
├── 9aa41ee1e12bb8a72dd240dc42b44ba5.gif
├── 9b468bff3f312fa70821da3a0a117f70.png
├── 9cb7a536001ffe21d63ecc68e368b4a0.png
├── 9d907772570668253e631c9235ac2623.png
├── a3767cf99551c83f2db7f46d52b340d3.png
├── a4bdf21cfdcad9b691198fa2486eaeb8.png
├── a54faa33502b8c17066b1e2af09bdbb0.png
├── a86c70fc9172e988971f8a4a6fdc5bd0.png
├── ab7e53a364737d98ee06c53aef3108b0.png
├── af8ae3176c5521d1cf12466ec3e2b54d.png
├── b2810b869602f1a37d43ed871c038020.png
├── b4acd55e80fa396e2883b6968d5189e1.png
├── b58fa402bb2b4e16e53b0bda44a0e30e.png
├── b5a20f07b4812ea9f34ffb8e8783b73a.png
├── b89dd5988d7d7ead6923dbc2d20e146c.png
├── b9bd3a0655d66dfdb5690e999db6ac32.png
├── bb111919295b7678530a1adcfa8b7d29.png
├── c3ab348e58c5eb81b71284b3807943e4.png
├── c59aebec0401c408755e8d427d973899.png
├── c649a1a7c43cffd86e55f28aeb8ff607.png
├── c7ef66e1ace9b544ba85d64f3f4ed1c4.gif
├── cb771856f5b0a021a92acc162c9c13bd.png
├── cba8723ae722e8d2d13b94e0cf1fda7a.png
├── ccb771014f600402fee72ca7134aea10.gif
├── cd74a05babfcb9f75a746c9e98f2789b.png
├── ce55033da131c4260c130ad3cb118bd5.png
├── ce8a6d4b9cd6df4c48cf914fae8a70d2.png
├── cfed8162c929bdf84a569ef649575563.png
├── d00bee2b821eb3d268b99fb6ea94f916.png
├── d06602b60d3af269409eb5633f8387c5.png
├── d4747b5b04d0887c1a49b974d187dc6f.png
├── d5e1fe52debddd4c5b288e3b6e9c5262.png
├── da7d6c8c12d18b915018939970d2b911.png
├── da82a95da8f5e01d5de56f221c22d65c.png
├── dccad19c5a07ffcd2477a9030d9337e7.gif
├── e2554f0ea244f337c0e66ea34bf53edf.gif
├── f01e9f4fd7eafca9b8a6eceeb6aec383.png
├── f06f930419cee402a7a5cac1de4b1557.png
├── f0839a5643114a83f16d647c8c8299d3.png
├── f25b3e3bc94bed108b0c454413f79873.png
├── f3b8490d4e41a8da5e954aabf0a4aacf.png
├── f558d2899635882ec517e2b1da5a0a8f.png
├── f621d8dd39147a621753b36d643cf42f.png
├── f67a3249ad8b040417f195c3ca11f795.png
├── fcbcd21ab48a370aa550ce594ade1794.png
├── fd0d20c24fda6e6b4d654a468ed84d2c.png
├── fd2c7004f31d57eb9822307aac8afef9.png
├── ff831787f6acc1e38a7f70dc47925ee0.gif
├── image-20240829080057376.png
├── image-20240829080659528.png
├── image-20240829081015123.png
├── image-20240829081049988.png
├── image-20240829081346732.png
├── image-20240829081541149.png
├── image-20240829081620633.png
├── image-20240829081719592.png
├── image-20240829081916316.png
├── image-20240829081950365.png
├── image-20240829082024079.png
├── image-20240829082055680.png
├── image-20240829082201268.png
├── image-20240829082231096.png
├── image-20240829082255780.png
├── image-20240829082344150.png
├── image-20240829082406694.png
├── image-20240829082635337.png
├── image-20240829082659498.png
├── image-20240829082837729.png
├── image-20240829082946033.png
├── image-20240829083025561.png
├── image-20240829083106816.png
├── image-20240829083417393.png
├── image-20240829083549751.png
├── image-20240829083610439.png
├── image-20240829083656994.png
├── image-20240829083740371.png
├── image-20240829083807720.png
├── image-20240829083858029.png
├── image-20240829083941927.png
├── image-20240829084258188.png
├── image-20240829084319943.png
├── image-20240829084347280.png
├── image-20240829084425105.png
├── image-20240829084512423.png
├── image-20240829084537503.png
├── image-20240829084610339.png
├── image-20240829084636349.png
├── image-20240829084700560.png
├── image-20240829084730629.png
├── image-20240829084841772.png
├── image-20240829084901737.png
├── image-20240829085005983.png
├── image-20240829085045336.png
├── image-20240829085119472.png
├── image-20240829085146797.png
├── image-20240829085209463.png
├── image-20240829085254141.png
├── image-20240829085727776.png
├── image-20240829085852775.png
├── image-20240829085935810.png
├── image-20240829090305653.png
├── image-20240829090434767.png
├── image-20240829090550499.png
├── image-20240829090612617.png
├── image-20240829090632045.png
├── image-20240829090658864.png
├── image-20240829091316193.png
├── image-20240829091450756.png
├── image-20240829091539440.png
├── image-20240829091801038.png
├── image-20240829092027870.png
├── image-20240829092050429.png
├── image-20240829092158912.png
├── image-20240829092329794.png
├── image-20240829092612681.png
├── image-20240829092656320.png
├── image-20240829092940314.png
├── image-20240829092959775.png
├── image-20240829093518737.png
├── image-20240829093552414.png
├── image-20240829093934212.png
├── image-20240829094221268.png
├── image-20240829095452552.png
├── image-20240829100209917.png
├── image-20240829100245272.png
├── image-20240829100432417.png
├── image-20240829100937477.png
├── image-20240829101111288.png
├── image-20240829101222447.png
├── image-20240829101254601.png
├── image-20240829101332034.png
├── image-20240829101534550.png
├── image-20240829101612063.png
├── image-20240829101632142.png
├── image-20240829101650730.png
├── image-20240829101712694.png
├── image-20240829101915930.png
├── image-20240829101936734.png
├── image-20240829101956608.png
├── image-20240829102020166.png
├── image-20240829102323261.png
├── image-20240829102344815.png
├── image-20240829102642856.png
├── image-20240829102703396.png
├── image-20240829103131857.png
├── image-20240829103236734.png
├── image-20240829103259992.png
├── image-20240829104222478.png
├── image-20240829104512068.png
├── image-20240829104533718.png
├── image-20240829104554155.png
├── image-20240829104639402.png
├── image-20240829104851205.png
├── image-20240829104924497.png
├── image-20240829104945257.png
├── image-20240829105004347.png
├── image-20240829105130499.png
├── image-20240829105242300.png
├── image-20240829105258689.png
├── image-20240829105418671.png
├── image-20240829105441723.png
├── image-20240829105506722.png
├── image-20240829105659262.png
├── image-20240829110009589.png
├── image-20240829110334937.png
├── image-20240829110513812.png
├── image-20240829110533157.png
├── image-20240829110551420.png
├── image-20240829110903709.png
├── image-20240829110922449.png
├── image-20240829110943245.png
├── image-20240829111514798.png
├── image-20240829111542163.png
├── image-20240829111619905.png
├── image-20240829111645952.png
├── image-20240829111711642.png
├── image-20240829111732678.png
├── image-20240829111753566.png
├── image-20240829111911455.png
├── image-20240829111935904.png
├── image-20240829111959287.png
├── image-20240829112229366.png
├── image-20240829112250200.png
├── image-20240829112326190.png
├── image-20240829112700824.png
├── image-20240829112906641.png
├── image-20240829113049624.png
├── image-20240829113113252.png
├── image-20240829113134905.png
├── image-20240829113628989.png
├── image-20240829113649785.png
├── image-20240829113734608.png
├── image-20240829113824280.png
├── image-20240829113916829.png
├── image-20240829113948830.png
├── image-20240829114017540.png
├── image-20240829114037360.png
├── image-20240829114100020.png
├── image-20240829114526325.png
├── image-20240829114557565.png
├── image-20240829114945572.png
├── image-20240829115033197.png
├── image-20240829115125819.png
├── image-20240829115210707.png
├── image-20240829115241352.png
├── image-20240829115301443.png
├── image-20240829115320081.png
├── image-20240829115410814.png
├── image-20240829115454755.png
├── image-20240829115606145.png
├── image-20240829115642934.png
├── image-20240829115703081.png
├── image-20240829115724267.png
├── image-20240829151638122.png
├── image-20240829151823981.png
├── image-20240829204745429.png
├── image-20240830114557281.png
├── image-20240830214738439.png
├── image-20240901095750255.png
├── image-20240901103231333.png
├── image-20240901104239714.png
├── image-20240902000000001.png
├── image-20240902000000002.png
├── image-20240902000000003.png
├── image-bulk-insert-degrade.png
├── image-bulk-insert-optimize.png
├── image-degrade.png
├── image-degrade2.png
├── image-degrade3.png
├── image-degrade4.png
├── image-join-degrade.png
├── image-join-improve.png
└── image-thread-pool.png
/Chapter1.md:
--------------------------------------------------------------------------------
1 | # Chapter 1: Traditional Methods for Solving MySQL Problems
2 |
3 | ## 1.1 Current State of Solving MySQL Problems
4 |
5 | Solving problems related to MySQL usage is generally straightforward and involves gathering information and applying logical reasoning, making these problems typically resolvable. However, tackling inherent problems within MySQL itself proves significantly more complex. Fortunately, MySQL users are resourceful and have devised various solutions, such as implementing thread pools to mitigate scalability challenges.
6 |
7 | To effectively solve the myriad problems of MySQL, relying solely on peripheral fixes and patches is inadequate. It's essential to delve into the core nature of these problems and comprehensively address them to achieve meaningful progress. For example, MySQL Group Replication has persistently struggled with instability. Despite robust development efforts, the ongoing challenge lies in adopting the correct problem-solving approach, resulting in difficulties in reducing bugs.
8 |
9 | ## 1.2 How Are MySQL Problems Solved?
10 |
11 | Here are some classic problems listed, along with typical resolutions in real-world MySQL usage scenarios.
12 |
13 | ### 1.2.1 Addressing Scalability Problems in MySQL 5.7
14 |
15 | The following figure illustrates the relationship between TPC-C throughput and concurrency in MySQL 5.7.39 under a specific configuration. This includes setting the transaction isolation level to Read Committed and adjusting the *innodb_spin_wait_delay* parameter to mitigate throughput degradation.
16 |
17 | 
18 |
19 | Figure 1-1. Scalability problems in MySQL 5.7.39 during BenchmarkSQL testing.
20 |
21 | From the figure, it is evident that scalability problems significantly limit the increase in MySQL throughput. For example, after 100 concurrency, the throughput begins to decline. Due to MySQL's historical scalability challenges, Percona even open-sourced a thread pool to address these problems. The following figure illustrates the relationship between TPC-C throughput and concurrency after configuring the Percona thread pool.
22 |
23 | 
24 |
25 | Figure 1-2. Percona thread pool mitigates scalability problems in MySQL 5.7.39.
26 |
27 | For MySQL 5.7.39, the thread pool effectively mitigates the decline in throughput degradation, although it also slightly reduces peak throughput due to inherent overhead costs. This overhead becomes more noticeable when comparing performance at lower concurrency levels.
28 |
29 | As MySQL 8.0 versions improve scalability, the effectiveness of the thread pool in mitigating throughput degradation diminishes. Subsequent chapters will provide real-world cases to substantiate this observation.
30 |
31 | ### 1.2.2 Enhancing Join Performance in MySQL
32 |
33 | Due to the absence of hash join support in MySQL 5.7, the following statistical SQL query took 3.82 seconds to execute.
34 |
35 | 
36 |
37 | Figure 1-3. Non-hash join performance in MySQL 5.7.
38 |
39 | In MySQL 8.0, the introduction of hash joins in the execution plan has improved join performance. For the same SQL query mentioned earlier, specifying hash join through comments reduced the execution time to just 1.22 seconds, a significant improvement from the previously observed 3.82 seconds.
40 |
41 | 
42 |
43 | Figure 1-4. Hash join performance in MySQL 8.0.
44 |
45 | This illustrates the improvement in join execution introduced in MySQL 8.0, highlighting one of its key advancements.
46 |
47 | ### 1.2.3 Challenges of MySQL Semisynchronous Replication in Large-Scale Deployments
48 |
49 | Since the introduction of the Paxos protocol, an increasing number of databases have adopted state machine replication to construct a highly available cluster.
50 |
51 | The Paxos protocol relies on a majority-based mechanism rooted in set theory to achieve consensus. For instance, in a cluster with 3 MySQL nodes, 2 nodes can form a majority. If these 2 nodes reach consensus, the system can operate continuously. Theoretically, adherence to this majority-based mechanism should prevent divergence or split-brain problems under any anomaly.
52 |
53 | Raft, another widely used protocol, is essentially a simplified version of the Paxos protocol. The following section describes Meta's implementation of MySQL high availability using the Raft protocol [38], which simplifies traditional high availability processes.
54 |
55 | 
56 |
57 | Figure 1-5. Reasons Meta uses raft.
58 |
59 | Meta's case study demonstrates that the new solution based on the Raft protocol simplifies high availability challenges. Raft is often viewed as a streamlined version of the Paxos protocol. Similarly, a Group Replication solution based on the Paxos protocol, if implemented correctly, could also offer an elegant solution.
60 |
61 | ### 1.2.4 Majority-Based Mechanism Performance and Its Accuracy
62 |
63 | With the transaction isolation level set to Read Committed, simulations based on Group Replication were conducted under various network latency conditions.
64 |
65 | The deployment setup of Group Replication is illustrated as follows: On machine A, two MySQL instances are deployed—one serving as the primary and the other as the secondary. These two instances form the majority and communicate via localhost. Machine B hosts a third instance deployed as a member of the cluster, with a network latency of X milliseconds.
66 |
67 | 
68 |
69 | Figure 1-6. Deployment diagram for majority-based mechanism performance testing.
70 |
71 | In theory, with a majority-based mechanism, a cluster of 3 nodes only needs responses from 2 nodes to provide results to the client. By this logic, local SysBench tests should demonstrate very high efficiency.
72 |
73 | Throughput comparisons over time have been conducted for machine B in scenarios within the same data center and across data centers with latencies of 10ms, 100ms, and 1000ms. Specific results are illustrated in the following figure.
74 |
75 | 
76 |
77 | Figure 1-7. Performance testing results of the default multi-leader Paxos algorithm.
78 |
79 | From the figure, it is evident that under the default mode of Group Replication, throughput across data centers deviates significantly from theoretical expectations. For example, in scenarios with 10ms network latency, the cluster's throughput decreases to one-fifth of its original level. To address this discrepancy, starting with MySQL 8.0.27, the *group_replication_paxos_single_leader* option was introduced. Enabling this option utilizes the single leader Paxos algorithm instead of the default multi-leader Paxos algorithm.
80 |
81 | After configuring Group Replication to use the single leader Paxos algorithm, tests were conducted under the same conditions using the SysBench testing tool. The test results are as follows.
82 |
83 | 
84 |
85 | Figure 1-8. Performance testing results of the single-leader Paxos algorithm.
86 |
87 | From the figure, it is evident that the results of the single leader mode are significantly better than previous results. However, the drawback is that the single leader mode can only function in MySQL's single-primary mode, and its application scope is limited, unable to be applied in scenarios requiring strong consistency for read and write operations.
88 |
89 | Is this modification to the underlying Paxos algorithm truly the optimal solution? This will be explored in depth in the following chapters.
90 |
91 | ### 1.2.5 Group Replication: Localhost Deployment Reports Unreachable
92 |
93 | Deploying Group Replication with two nodes on the same machine, where communication between these nodes occurs via localhost, theoretically should not encounter network-related jitter, packet loss, or problems with unreachable peers under normal conditions.
94 |
95 | 
96 |
97 | Figure 1-9. Localhost deployment relationships displayed by Performance Schema.
98 |
99 | During TPC-C data loading tests with BenchmarkSQL under normal pressure, the MySQL error logs revealed multiple instances of the primary and secondary nodes reporting each other as unreachable.
100 |
101 | Here is a partial screenshot of the error log from the MySQL primary:
102 |
103 | 
104 |
105 | Figure 1-10. A partial screenshot of the error log from the MySQL primary.
106 |
107 | Here is a partial screenshot of the error log from the MySQL secondary:
108 |
109 | 
110 |
111 | Figure 1-11. A partial screenshot of the error log from the MySQL secondary.
112 |
113 | From these logs, warnings indicating 'has become unreachable' are evident. Under normal conditions, frequent 'unreachable' reports in a localhost scenario like this are unexpected. Blaming the network for Group Replication's delayed problem handling isn't optimal. Future chapters will explore enhancements to the network probing mechanism to address these false reporting problems.
114 |
115 | ## 1.3 Summary
116 |
117 | This chapter analyzed how users approach solving MySQL problems. MySQL 8.0 has made strides in improvement, notably in mitigating scalability problems and introducing support for hash joins, which is a positive development. However, there remain numerous unsolved problems, both longstanding and newly emerging. Effectively addressing MySQL problems demands a thorough understanding of the problems and relevant theories; otherwise, the understanding may be incomplete.
118 |
119 | The next chapter will demonstrate the considerable challenge of solving obscure MySQL problems through various case studies. It necessitates a broad knowledge base and extensive logical reasoning to pinpoint the root causes of these problems.
120 |
121 | [Next](Chapter2.md)
122 |
--------------------------------------------------------------------------------
/Chapter12.md:
--------------------------------------------------------------------------------
1 | # Chapter 12: Future Directions
2 |
3 | A solid foundation is essential for advancing MySQL towards more complex objectives. Once scalability and high availability are resolved, the focus could shift to the following development areas.
4 |
5 | ## 12.1 Improvements to Hypergraph Algorithms
6 |
7 | The goal is to make hypergraph algorithms practical and enhance their performance, with a focus on exploring parallel approaches.
8 |
9 | ## 12.2 Practical Implementation of Paxos Log Persistence Functionality
10 |
11 | Currently, Paxos log persistence has been demonstrated to be feasible. Efforts can be made to implement crash recovery based on Paxos logs, thereby making Paxos log persistence truly practical.
12 |
13 | ## 12.3 Addressing Concurrent View Change Challenges
14 |
15 | Currently, Group Replication faces challenging concurrent view change problems. Although these issues occur infrequently, efforts can be made to solve them completely.
16 |
17 | ## 12.4 Further Improving Scalability
18 |
19 | MySQL scalability can be further improved in the following areas:
20 |
21 | 1. Eliminating additional latch bottlenecks, particularly in non-partitioned environments.
22 | 2. Improving the stability of long-term performance testing.
23 | 3. Improving MySQL's NUMA-awareness in mainstream NUMA environments.
24 | 4. Addressing Performance Schema's adverse impact on NUMA environments during MySQL secondary replay processes.
25 |
26 | ## 12.5 Further Improving SQL Performance Under Low Concurrency
27 |
28 | MySQL 8.0's performance under low concurrency is significantly worse compared to 5.7, which needs to be corrected to avoid affecting users upgrading to 8.0.
29 |
30 | ## 12.6 Further Enhancing Performance of Analytical SQL Queries
31 |
32 | Currently, MySQL processes individual SQL queries using a single-threaded mode, which can result in excessively long processing times for some statistical queries and significantly impact user experience. Future improvements will focus on implementing multi-threaded processing for statistical SQL queries to reduce processing times and enhance performance.
33 |
34 | ## 12.7 Improving Binlog File Compression Efficiency and Operational Stability
35 |
36 | Reducing user storage costs is a key focus. Optimizing MySQL binlog compression rates and operational stability presents significant potential for improvement, which could lead to substantial benefits.
37 |
38 | ## 12.8 Advancing MySQL's Management of Large Transactions on the Primary Server
39 |
40 | In mainstream NUMA environments, MySQL's primary server efficiency in handling large transactions is suboptimal. This area has significant optimization potential and could become one of the key points for future improvements.
41 |
42 | ## 12.9 Further Exploring Better Memory Allocation Tools
43 |
44 | Currently, jemalloc 4.5 is the best-found memory allocation tool, but it has high memory consumption and instability on ARM architecture. A key future focus could be developing a more efficient and stable memory allocation tool.
45 |
46 | ## 12.10 Integrating a High-Performance File System
47 |
48 | Enhancing MySQL with a better file system, especially improving the performance of MySQL secondary replay.
49 |
50 | ## 12.11 Introducing AI into MySQL Systems
51 |
52 | Integrating AI with MySQL for automated knob tuning and learning-based database monitoring could be another key focus for the future.
53 |
54 | ### 12.11.1 Knob Tuning
55 |
56 | Integrating AI for parameter optimization can significantly reduce DBA workload. Key parameters suitable for AI-driven optimization include:
57 |
58 | 1. Buffer pool size
59 | 2. Spin delay settings
60 | 3. Dynamic transaction throttling limits based on environment
61 | 4. Dynamic XCom cache size adjustment
62 | 5. MySQL secondary worker max queue size
63 | 6. The number of Paxos pipelining instances and the size of batching
64 | 7. Automatic parameter adjustments under heavy load to improve processing capability
65 |
66 | ### 12.11.2 Learning-based Database Monitoring
67 |
68 | AI could optimize database monitoring by determining the optimal times and methods for tracking various database metrics.
69 |
70 | ## 12.12 Summary
71 |
72 | Programming demands strong logical reasoning skills, crucial for problem-solving, algorithm design, debugging, code comprehension, performance optimization, and testing. It helps in analyzing problems, creating solutions, correcting errors, and ensuring software reliability. Developing logical reasoning is essential for programmers to think systematically and build efficient, reliable software [56].
73 |
74 | MySQL development often focuses primarily on simple tests using testing tools, which can miss opportunities to discover many problems. Testing MySQL itself is a monumental task, and relying solely on testing tools is insufficient to expose all problems. Optimization differs across projects and environments, and using real online traffic makes it more targeted and effective. Thus, MySQL optimization based on live traffic is highly valuable.
75 |
76 | MySQL performance optimization heavily relies on mitigating scalability problems. Enhanced versions of MySQL have addressed most scalability problems, establishing a solid foundation for further optimizations. Profile-guided optimization (PGO) is crucial for MySQL, and as scalability problems improve, its importance will continue to grow. Utilizing better memory allocation tools can significantly improve the performance of both the MySQL primary and secondary replay.
77 |
78 | We firmly believe that high availability solutions based on Paxos log persistence will be the future trend. Our extensive experience in the long-term transformation of Group Replication has laid a solid foundation for achieving true high availability. The speed of MySQL secondary replay determines the quality of MySQL's high availability. Achieving replay speeds in the range of millions of tpmC is possible but requires persistent effort.
79 |
80 | Although MySQL optimization is a long and winding process, we are confident that MySQL will continue to improve over time.
81 |
82 | [Next](References.md)
--------------------------------------------------------------------------------
/Chapter4.md:
--------------------------------------------------------------------------------
1 | # Chapter 4: Fundamentals of Computer Science
2 |
3 | To effectively address MySQL's myriad problems, a solid foundation in computer science is indispensable. MySQL not only encapsulates a wealth of computer science principles but also presents learners with diverse challenges, offering valuable practical experience. This chapter centers on essential computer science fundamentals necessary for solving MySQL problems. The emphasis is on applying this foundational knowledge in practical scenarios, rather than theoretical teaching.
4 |
5 | [4.1 System Architecture](Chapter4_1.md)
6 |
7 | [4.2 Data Structure](Chapter4_2.md)
8 |
9 | [4.3 Algorithm](Chapter4_3.md)
10 |
11 | [4.4 Operating system](Chapter4_4.md)
12 |
13 | [4.5 Compiler Theory](Chapter4_5.md)
14 |
15 | [4.6 Queueing Theory](Chapter4_6.md)
16 |
17 | [4.7 Computer Networking](Chapter4_7.md)
18 |
19 | [4.8 Performance Optimization](Chapter4_8.md)
20 |
21 | [4.9 Distributed Theory](Chapter4_9.md)
22 |
23 | [4.10 Database Fundamentals](Chapter4_10.md)
24 |
25 | [4.11 Software Architecture Design](Chapter4_11.md)
26 |
27 | [4.12 Software Testing](Chapter4_12.md)
28 |
29 | [Next](Chapter4_1.md)
30 |
--------------------------------------------------------------------------------
/Chapter4_1.md:
--------------------------------------------------------------------------------
1 | ## 4.1 System Architecture
2 |
3 | System architecture defines the high-level structure of a software or hardware system, detailing its components, their interrelationships, and how they collaborate to fulfill system objectives.
4 |
5 | ### 4.1.1 SMP
6 |
7 | In an SMP (Symmetric Multiprocessing) system, multiple tightly-coupled processors share all resources such as bus, memory, and I/O system. This architecture facilitates equal access to memory, peripherals, and the operating system across all CPUs without distinction, emphasizing shared resource utilization among processors.
8 |
9 | The following is a typical SMP architecture diagram.
10 |
11 | 
12 |
13 | Figure 4-1. A typical SMP architecture.
14 |
15 | In this setup, access to local L1 and L2 caches is extremely fast, and the overhead of CPU switching is minimal compared to NUMA architecture. SMP architecture typically supports moderate throughput under normal conditions. However, it is the inability of SMP to scale effectively for higher throughput demands that led to the development of NUMA architecture.
16 |
17 | ### 4.1.2 NUMA
18 |
19 | In the era of increasingly multicore systems, memory hierarchy is evolving towards non-uniform distributed architectures. Non-uniform memory architecture (NUMA) systems, which offer superior scalability compared to SMP counterparts, feature multiple memory nodes distributed throughout the system. Each node is physically adjacent to a subset of cores, but the entire physical address space of all nodes is globally visible, allowing cores to access memory locally or remotely. Consequently, data access times are non-uniform and vary based on data location. Accessing data from a remote node can lead to performance degradation due to latency and interconnect contention if many cores access large amounts of data remotely. These problems can be mitigated by co-locating threads with their data whenever possible, facilitated by NUMA-aware scheduling algorithms.
20 |
21 | The throughput of the cross-chip interconnect is typically lower than that of on-chip memory controllers. Remote memory accesses that traverse this interconnect also experience higher latencies compared to local memory accesses. Due to the diversity in their memory interfaces, these multiprocessors are categorized as NUMA systems. The performance impact of remote memory accesses can be significant; in current implementations, the NUMA factor can result in up to a 2X slowdown for certain applications.
22 |
23 | NUMA nodes are interconnected within the same physical server. When a CPU needs to access remote memory, it incurs a wait time. This limitation is fundamental to why NUMA servers struggle to achieve linear performance scalability as CPUs increase [52].
24 |
25 | Here is the classic architecture figure of NUMA.
26 |
27 | 
28 |
29 | Figure 4-2. A typical NUMA architecture.
30 |
31 | Access within the same NUMA node can be compared to a specialized form of SMP access, where its efficiency primarily comes from reduced CPU switching costs within the NUMA node. However, a drawback is that memory bandwidth within the same NUMA node can quickly become a bottleneck, constraining scalability. Accessing memory between different NUMA nodes involves higher costs, but it offers greater overall memory bandwidth. Effectively managing memory access in a NUMA environment poses a significant challenge.
32 |
33 | The figure below illustrates the comparison results of TPC-C tests across different concurrency levels. The dark blue curve shows tests conducted with NUMA node 0 fixed, while the deep red curve represents tests utilizing all 4 NUMA nodes of the machine. The testing employed an improved version of MySQL, operating with 1000 warehouses and using the widely adopted Read Committed transaction isolation level.
34 |
35 | 
36 |
37 | Figure 4-3. Performance Comparison in SMP vs. NUMA.
38 |
39 | In the scenario where NUMA node 0 is bound, the throughput versus concurrency curve is notably smooth. Even under high concurrency, there is only a slight decline in throughput, indicating low thread context switching costs [60]. However, throughput consistently remains below 400,000 tpmC due to significant limitations in memory bandwidth, characteristic of traditional SMP architecture.
40 |
41 | In contrast, when utilizing all NUMA nodes, the throughput curve is relatively worse. This is attributed to reduced memory efficiency and increased context switching costs when accessing across NUMA nodes, resulting in less stable throughput. Nevertheless, scalability is greatly improved, with peak throughput increasing by 123% compared to using a single NUMA node.
42 |
43 | Using 4 NUMA nodes does not result in four times the throughput; instead, it is approximately 2.x times that of a single NUMA node. This non-linear scaling is inherent to NUMA architecture and is compounded by MySQL's challenges in linear scalability.
44 |
45 | MySQL's difficulties in achieving linear scalability arise from several factors, including the Read Committed transaction isolation mechanism based on MVCC ReadView. This involves copying a global ReadView to a local one, leading to contention among threads for global ReadView updates. Moreover, in NUMA environments, frequent cross-NUMA node accesses are necessary, further complicating scalability.
46 |
47 | Many pieces of code are not suitable for NUMA environments. For example, frequent latch contention in critical sections can lead to frequent cross-NUMA node context switches. Slow operations within critical sections can cause inefficient program execution due to frequent cache migrations across NUMA nodes.
48 |
49 | To achieve optimal performance on NUMA systems [4], the following strategies are crucial:
50 |
51 | 1. Maximize the proportion of memory accesses routed to local nodes.
52 | 2. Balance traffic across nodes and interconnect links.
53 |
54 | An unbalanced distribution of memory requests can significantly increase memory access latency on overloaded controllers, sometimes reaching up to 1000 cycles compared to approximately 200 cycles on non-overloaded controllers.
55 |
56 | While Microsoft SQL Server and Oracle DBMS are NUMA-aware, MySQL is not [5]. Therefore, large-scale applications like MySQL, which lack NUMA awareness, offer significant optimization potential in NUMA environments.
57 |
58 | Interestingly, for MySQL, disabling NUMA can potentially improve performance. According to a case study in Section 2.9, disabling NUMA configuration in the BIOS improved performance for the MySQL primary. This adjustment impacts memory allocation strategies, leading to more consistent memory access between NUMA nodes. This aligns with optimization strategy 2 mentioned above, benefiting MySQL's throughput and stability.
59 |
60 | ### 4.1.3 X86 Architecture
61 |
62 | X86 uses a complex system called CISC (Complex Instruction Set Computing). This can do a lot of tasks at once but makes the processor more complicated and expensive to create. X86 architectures allow more direct interaction with memory, facilitating a depth of computational tasks at the expense of higher power consumption [45]. Overall, x86 has higher performance capabilities, ideal for demanding computational tasks.
63 |
64 | For mainstream NUMA machines utilizing the x86 architecture, please refer to the figure below for an analysis of memory access overhead between different NUMA nodes on a specific machine:
65 |
66 | 
67 |
68 | Figure 4-4. Node distances in a typical x86 architecture.
69 |
70 | From the figure, it is evident that under the x86 architecture, the access overhead is 10 units for accessing the local node and 21 units for accessing remote NUMA nodes. Below are the TPC-C test results of improved MySQL 8.0.27 with BenchmarkSQL:
71 |
72 | 
73 |
74 | Figure 4-5. Performance comparison under different NUMA bindings in a typical x86 architecture.
75 |
76 | Under the x86 architecture, the addition of each NUMA node results in a noticeable increase in high-concurrency throughput. This highlights the robust performance capabilities of x86 architecture in effectively managing memory access across NUMA nodes, thereby leveraging its full potential for high-performance computing.
77 |
78 | ### 4.1.4 ARM Architecture
79 |
80 | Historically, ARM processors have prioritized power efficiency, dominating the mobile systems market, whereas x86 processors have led in high-performance computing. The primary distinction between ARM and x86 processors lies in their instruction sets: ARM utilizes the RISC (Reduced Instruction Set Computing) architecture, which simplifies instructions to enhance speed and energy efficiency. This simplicity makes ARM ideal for battery-powered devices like smartphones [47]. In contrast, x86 employs the CISC (Complex Instruction Set Computing) architecture, which supports a wider range of complex operations but typically consumes more power.
81 |
82 | Regarding memory handling, ARM processors focus on register-based processing to minimize direct memory access, thereby improving energy efficiency. In contrast, x86 architectures allow for more direct interaction with memory, enabling a broader range of computational tasks at the cost of higher power consumption. Servers based on ARM architecture are renowned for their low power consumption and cost-effectiveness. However, they generally exhibit lower overall performance compared to x86 architecture and may have limitations in memory access scalability.
83 |
84 | For mainstream NUMA machines utilizing the ARM architecture, please refer to the figure below to observe the memory access overhead between different NUMA nodes on a specific machine:
85 |
86 | 
87 |
88 | Figure 4-6. Node distances in a typical ARM architecture.
89 |
90 | The memory access overhead between different NUMA nodes under the ARM architecture is notably more complex and varies significantly compared to the x86 architecture.
91 |
92 | Here are the test results on an ARM machine, using MySQL code and configuration similar to those on an x86 machine, with approximately the same settings, including 1000 warehouses.
93 |
94 | 
95 |
96 | Figure 4-7. Performance comparison under different NUMA bindings in a typical ARM architecture.
97 |
98 | From the figure, it is evident that binding NUMA node 0 and 1 significantly improves throughput. However, adding NUMA node 2 does not noticeably improve throughput, primarily due to NUMA node distances inherent in the ARM architecture. Extensive testing has revealed that MySQL demonstrates better scalability on x86 architecture compared to ARM.
99 |
100 | [Next](Chapter4_2.md)
101 |
--------------------------------------------------------------------------------
/Chapter4_10.md:
--------------------------------------------------------------------------------
1 | ## 4.10 Database Fundamentals
2 |
3 | Database management platforms are expected to provide application programmers with an abstraction of ACID transactions, freeing them from concerns about anomalies that might arise from concurrency or failure [19]. This section provides a brief introduction to the fundamentals of general relational databases. Advanced fundamentals of MySQL will be covered in the next chapter.
4 |
5 | ### 4.10.1 Relational Model and SQL Language
6 |
7 | The relational model, based on predicate logic and set theory, is a fundamental data model in databases. SQL (Structured Query Language) is a highly successful programming language, simplifying database interaction by allowing users to specify their requirements without needing to understand the underlying implementation.
8 |
9 | The relational model and SQL are elegantly designed. Their invention required significant imagination to use a relational model and SQL for solving data storage problems, as is common today. Their success is largely due to their scalability and ease of use.
10 |
11 | SQL is relatively easy to use and widely accepted in database systems. However, it lacks some complex processing patterns (e.g., iterative training) compared to other high-level machine learning languages. Fortunately, SQL can be extended to support AI models, and user-friendly tools can be designed to support AI models in SQL statements [55].
12 |
13 | Using AI to generate SQL queries is also a promising direction for the continued development of SQL.
14 |
15 | ### 4.10.2 Database Security
16 |
17 | Security and ease of use often present a trade-off for users, requiring corresponding decisions based on their needs. To enhance security, MySQL utilizes TLS/SSL encrypted communication, ensuring that client-server interactions are encrypted. This increases security but adds complexity to problem analysis. For instance, analyzing encrypted SQL content captured using packet sniffing tools can be challenging.
18 |
19 | ### 4.10.3 Database Integrity
20 |
21 | Database integrity refers to the logical consistency, correctness, validity, and compatibility of data within a database. It is ensured through various integrity constraints, making database integrity design synonymous with the design of these constraints.
22 |
23 | For a standalone MySQL instance, maintaining database integrity is relatively straightforward compared to implementing it in Group Replication multi-primary mode. For instance, as noted in [13], Group Replication does not support the following features.
24 |
25 | 
26 |
27 | ### 4.10.4 SQL Rewrite
28 |
29 | Many database users, especially those in the cloud, may not write high-quality SQL queries. SQL rewriters aim to transform these queries into more efficient forms, such as pushing down filters or transforming nested queries into join queries [55]. Transforming SQL queries into equivalent high-quality versions is thus a very meaningful endeavor.
30 |
31 | ### 4.10.5 SQL Injection
32 |
33 | SQL injection is a common and harmful vulnerability to databases. Attackers can exploit this vulnerability to modify or view data beyond their privileges by bypassing authentication or interfering with SQL statements, resulting in actions such as retrieving hidden data, subverting application logic, and performing union attacks [55].
34 |
35 | For MySQL, preventing SQL injection involves several strategies. Besides using encrypted communication, users could employ prepared statements to avoid SQL injection. Prepared statements ensure that SQL code is separated from data inputs, significantly reducing the risk of injection attacks.
36 |
37 | ### 4.10.6 The Significant Impact of Indexes on Performance
38 |
39 | In DBMS, indexes are vital for speeding up query execution, and selecting appropriate indexes is crucial for achieving high performance [55]. Below are the additional indexes created for BenchmarkSQL TPC-C testing, on top of the default indexes:
40 |
41 | ```
42 | create index bmsql_oorder_index on bmsql_oorder (o_c_id);
43 | ```
44 |
45 | The additional indexes are created to improve TPC-C throughput. The figure below shows the relationship between TPC-C throughput and concurrency before and after index addition.
46 |
47 | 
48 |
49 | Figure 4-68. Comparison of BenchmarkSQL tests before and after index addition.
50 |
51 | From the figure, it can be seen that establishing an effective index can significantly improve MySQL TPC-C throughput.
52 |
53 | ### 4.10.7 State-Machine Replication
54 |
55 | The most general approach to providing a highly available service is to use a replicated state machine architecture. With a deterministic service, the state and function are replicated across servers, and an unbounded sequence of consensus instances agrees upon the commands executed. This approach offers strong consistency guarantees and is broadly applicable [32].
56 |
57 | State-machine replication is a well-established method for fault tolerance. It replicates a service on multiple servers, maintaining availability despite server failures. However, it has two performance limitations: it introduces overhead in response time due to the need to totally order commands, and service throughput cannot be increased by adding more replicas.
58 |
59 | Group Replication is an implementation of state-machine replication. Extensive fixes and improvements have been made based on native MySQL, significantly enhancing stability and performance. Subsequent chapters will detail these improvements to Group Replication.
60 |
61 | [Next](Chapter4_11.md)
62 |
--------------------------------------------------------------------------------
/Chapter4_11.md:
--------------------------------------------------------------------------------
1 | ## 4.11 Software Architecture Design
2 |
3 | Common software architectures include layered architecture, primary-secondary/multi-primary architecture, and event-driven architecture. A standalone MySQL instance processing employs a layered architecture, while a cluster utilizes either primary-secondary or multi-primary architecture. At the lower level of communication, Paxos employs an event-driven architecture. Therefore, MySQL can be described as a hybrid of multiple architectural styles.
4 |
5 | ### 4.11.1 Layered Architecture
6 |
7 | Layered architecture is a widely adopted architectural style that separates different concerns into layers to address varying requirements independently. For example, the TCP/IP protocol stack is one of the most successful layered architectures, widely used in the Internet domain. MySQL itself is based on a layered architecture, enabling it to support various types of storage engines. The processing model of Group Replication similarly follows a layered architecture, as depicted in the diagram [13].
8 |
9 | 
10 |
11 | Figure 4-69. Group Replication plugin block diagram.
12 |
13 | MySQL Server interacts with the Group Replication plugin through API calls. When a transaction needs to go through the Group Replication process, MySQL Server sends the transaction information to a designated queue via the Group Communication System API. Subsequently, the user thread enters a wait state, waiting for activation by threads responsible for Group Replication. The underlying Paxos layer (referred to as the Group Communication Engine in the diagram) is responsible for broadcasting the queue contents to group members. Once consensus is reached through the Paxos protocol, the upper layers are notified to proceed with further processing.
14 |
15 | How is the scalability of this architecture? The following figure illustrates the relationship between Group Replication throughput and concurrency. Additionally, transaction throttling mechanisms are utilized to improve the scalability of InnoDB under scenarios with 2000+ concurrency, ensuring that too many user threads do not enter the InnoDB transaction system.
16 |
17 | 
18 |
19 | Figure 4-70. Group Replication TPC-C throughput in BenchmarkSQL with transaction throttling mechanisms.
20 |
21 | From the figure, it can be seen that the architecture of Group Replication exhibits good inherent scalability, as the throughput does not sharply decrease with an increase in the number of threads.
22 |
23 | ### 4.11.2 Primary-Secondary/Multi-Primary Architecture
24 |
25 | MySQL asynchronous replication, semisynchronous replication, and Group Replication single-primary all employ primary-secondary architectures. In MySQL, the primary executes transactions while the secondary replays them, and there is no need for synchronous coordination of writes between the primary and the secondary.
26 |
27 | In a Group Replication multi-primary architecture, although transactions can be executed on any node, there are several known shortcomings:
28 |
29 | 1. Lack of a global transaction manager.
30 | 2. Limited transaction isolation levels.
31 | 3. Potential for traffic skew under heavy write pressure.
32 |
33 | According to user feedback, users often utilize Group Replication multi-primary in the following ways:
34 |
35 | 1. They require that transactions between nodes do not conflict with each other.
36 | 2. Despite being multi-primary, transactions are executed on only one node to avoid the overhead of switching primaries.
37 |
38 | The following figure shows SysBench's read-write performance over time, where each node accesses the same database and handles both read and write tasks.
39 |
40 | 
41 |
42 | Figure 4-71. Group Replication throughput in SysBench read-write tests over time.
43 |
44 | From the figure, it can be seen that the read-write tests between nodes coexist relatively harmoniously. The following figure shows SysBench write-only tests over time, where the Group Replication multi-primary architecture exhibits unstable throughput.
45 |
46 | 
47 |
48 | Figure 4-72. Group Replication throughput in SysBench write only tests over time.
49 |
50 | Next, let's continue to examine the testing scenario in the Group Replication multi-primary architecture, where transactions between nodes do not conflict. Testing is conducted on primary one for Database one and on primary two for Database two. This setup ensures that transactions executed by primary one and primary two have no possibility of conflict. The specific results are shown in the following figure:
51 |
52 | 
53 |
54 | Figure 4-73. Group Replication throughput in SysBench write only tests: high concurrency and no conflicts over time.
55 |
56 | From the figure, it can be seen that even without conflicts between transactions on different nodes, there is still throughput skew. The "primary one" node is primarily replaying transactions, severely limiting its capacity to accept new transactions.
57 |
58 | Notably, these tests were conducted with 100 concurrency. Reducing the pressure to 10 concurrency alleviates the uneven traffic skew, as shown in the figure below.
59 |
60 | 
61 |
62 | Figure 4-74. Group Replication throughput in SysBench write only tests: low concurrency and no conflicts over time.
63 |
64 | The tests indicate that the scalability of the Group Replication multi-primary architecture is problematic and can only support small-scale traffic.
65 |
66 | ### 4.11.3 Event-Driven Architecture
67 |
68 | Based on event-driven architecture, common in web servers like Nginx, Percona's thread pool can be seen as a rough approximation of event-driven systems. However, event-driven architecture isn't free—it incurs overhead from system calls, and this additional overhead constitutes the cost of using a thread pool.
69 |
70 | MySQL's underlying Paxos communication can also be viewed as asynchronous event-driven. This communication operates in a single-threaded mode, requiring the avoidance of any synchronous communication processes. Unfortunately, MySQL has gradually violated these principles in its ongoing feature expansion, leading to throughput problems in certain scenarios due to prolonged synchronous processes dropping to zero. For problems related to Group Replication synchronization, see the code snippet below.
71 |
72 | ```c++
73 | /* Try to connect to another node */
74 | static int dial(server *s) {
75 | DECL_ENV
76 | int dummy;
77 | ENV_INIT
78 | END_ENV_INIT
79 | END_ENV;
80 | TASK_BEGIN
81 | IFDBG(D_BUG, FN; STRLIT(" dial "); NPUT(get_nodeno(get_site_def()), u);
82 | STRLIT(s->srv); NDBG(s->port, u));
83 | // Delete old connection
84 | reset_connection(s->con);
85 | X_FREE(s->con);
86 | s->con = nullptr;
87 | s->con = open_new_connection(s->srv, s->port, 1000); // synchronous call
88 | if (!s->con) {
89 | s->con = new_connection(-1, nullptr);
90 | }
91 | ```
92 |
93 | [Next](Chapter4_12.md)
94 |
--------------------------------------------------------------------------------
/Chapter4_12.md:
--------------------------------------------------------------------------------
1 | ## 4.12 Software Testing
2 |
3 | ### 4.12.1 The Importance of Testing for MySQL Developers
4 |
5 | Testing and development are inseparable for MySQL developers. Due to the complex internal mechanisms of MySQL, external testers often struggle to grasp its logic and typically can only conduct black-box testing. Given MySQL's complexity, as many test cases as possible are generally required to reduce the workload of regression testing. Therefore, MySQL developers need to understand how to effectively utilize test cases to test their own programs.
6 |
7 | ### 4.12.2 Balancing Test Cases and Development Efficiency
8 |
9 | Not every problem necessitates designing test cases; sometimes, the complexity of designing test cases exceeds that of fixing the code. For example, with Paxos-based communication within MySQL, there are no specific test cases, primarily relying on extensive manual testing by developers.
10 |
11 | The principle of test case design should be to provide test cases where the cost is reasonable, avoiding them where the cost is excessive. Balancing this relationship effectively improves development efficiency.
12 |
13 | It's worth noting that the test cases for Group Replication have been found to be too lax, leading to significant challenges in regression testing after refactoring. Excessive and lax test cases can consume substantial development time, making it difficult to determine whether the problem lies with the test cases themselves or with the refactored code.
14 |
15 | ### 4.12.3 Ensuring Consistency in the Testing Environment
16 |
17 | Testing results can fluctuate due to various environmental factors, necessitating consistent environments to ensure fairness. The introduction of SSDs has significantly reduced MySQL's I/O wait times; however, if SSD performance degradation is not monitored during testing, results may diverge from expectations. Using commands such as ***fstrim -a*** can mitigate SSD degradation effects, ensuring tests are less affected.
18 |
19 | Linux operating systems utilize I/O caching, which can lead to variability in test results, especially over long intervals between tests. Therefore, it's advisable to minimize the time gap between two tests and repeat the initial test to assess fluctuations. If significant, the test results may become invalid.
20 |
21 | In this book, testing tools like BenchmarkSQL or SysBench are typically employed. BenchmarkSQL increases data volume over time, so for fairness and comparability of performance, tests commence after database refactoring to ensure reproducibility of results.
22 |
23 | ### 4.12.4 How to Test Efficiently?
24 |
25 | The most efficient testing method is to utilize real online traffic for evaluation directly. However, this can be too risky for databases. A safer approach is to replicate online traffic into a dedicated testing environment.
26 |
27 | In Oracle, Database Replay enables testing a system with real production workloads, helping identify potential problems before implementing changes on the production system. Any workload period can be captured with little overhead and used to drive a test system, maintaining the concurrency and load characteristics of the real workload. Maintaining these characteristics is crucial, as current testing solutions often lack synchronization based on data dependencies. Without proper synchronization, the workload does not perform as required, leading to poor coverage and inadequate load, leaving many problems undetected. Database Replay's data-based synchronization makes testing realistic and helps discover potential problems [34].
28 |
29 | In MySQL, a common strategy involves taking a MySQL secondary instance offline for testing, configuring the necessary cluster, and replicating online MySQL requests to this new testing primary. The closer the testing primary resembles the production environment, the more accurate the test results. There are various methods to replicate online MySQL requests. This book recommends the open-source tool TCPCopy [65]. By using [TCPCopy]([TCP Handshake & TCPCopy Replication Animation](https://enhancedformysql.github.io/animation/how_tcpcopy_works.html)), many online problems have been successfully effectively resolved, laying a solid foundation for MySQL proxy enhancements [66]. For testing a MySQL cluster, replicating online requests to the testing system using TCPCopy allows us to evaluate whether the modifications achieve the expected outcomes, such as performance improvements, and robustness.
30 |
31 | ### 4.12.5 Is Testing About Discovering Problems or Verifying Them?
32 |
33 | Testing serves not only to verify known problems but also to uncover new ones. Verification of problems is the initial step to ensure that the software behaves as expected. Subsequently, the focus shifts to actively discovering potential problems within the program, preempting their discovery by testers. Adopting this strategy during the process of improving MySQL fundamentally ensures the quality of MySQL modifications. Practical experience has validated this approach as highly effective. Where possible, replicating online traffic for testing provides a robust means to identify potential problems within the software, further enhancing its overall quality.
34 |
35 | [Next](Chapter5.md)
36 |
--------------------------------------------------------------------------------
/Chapter4_5.md:
--------------------------------------------------------------------------------
1 | ## 4.5 Compiler Theory
2 |
3 | Compiler Theory is a crucial computer science course that covers the fundamental principles and methods of compiler construction. It includes topics such as language and grammar, lexical analysis, syntax analysis, syntax-directed translation, intermediate code generation, memory management, code optimization, and target code generation. Central to the course is the finite state machine.
4 |
5 | ### 4.5.1 Finite State Machine
6 |
7 | A finite state machine (FSM) is a mathematical model used to represent a finite number of states, transitions, and actions within a system. FSMs are essential in various fields such as compilers, network protocols, and game engines, where they describe complex systems, algorithms, and event responses. The core concept of FSMs is state transition, which defines the relationships and actions between different states.
8 |
9 | In MySQL, FSMs play a crucial role in lexical and syntax analysis, as well as in Group Replication. For example, in Group Replication, FSMs help manage decisions during Paxos handling, such as whether to continue processing or to exit with an error if memory allocation fails. Typically, if a state cannot continue processing, it exits with an error to prevent Byzantine faults.
10 |
11 | FSMs are also used in TCP/IP protocols to detect abnormal states. For instance, a high number of *CLOSE WAIT* states on server-side TCP connections can indicate that many connections have not been closed properly.
12 |
13 | ### 4.5.2 MySQL Parser
14 |
15 | The MySQL Parser, implemented in C/C++, uses GNU Bison and Flex for parsing SQL queries. Flex generates tokens, while Bison handles syntax parsing. SQL parsing is crucial for operations like read/write evaluations by MySQL proxy and translating SQL into syntax trees.
16 |
17 | With the increase in CPU core count, the CPU overhead for MySQL parsing has become a smaller proportion of overall usage. This reduction in overhead might explain why MySQL 8.0 removed the query cache.
18 |
19 | ### 4.5.3 PGO
20 |
21 | Profile-guided optimization (PGO) is a compiler technique that improves program performance by using profiling data from test runs of the instrumented program. Rather than relying on programmer-supplied frequency information, PGO leverages profile data to optimize the final generated code, focusing on frequently executed areas of the program. This method reduces reliance on heuristics and can improve performance, provided the profiling data accurately represents typical usage scenarios.
22 |
23 | Extensive practice has shown that MySQL's large codebase is especially well-suited for PGO. However, the effectiveness of PGO can be influenced by I/O storage devices and network latency. On systems with slower I/O devices, like hard drives, I/O becomes the primary bottleneck, limiting PGO's performance gains due to Amdahl's Law. In contrast, on systems with faster I/O devices such as NVMe SSDs, PGO can lead to substantial performance improvements. Network latency also affects PGO effectiveness, with higher latency generally reducing the benefits.
24 |
25 | In summary, while MySQL 8.0's PGO capabilities can greatly improve computational performance, the actual improvement depends on the balance between computational and I/O bottlenecks in the server setup. The following figure demonstrates that with NVMe SSD hardware configuration and NUMA binding, PGO can significantly improve the performance of MySQL.
26 |
27 | 
28 |
29 | Figure 4-22. Performance comparison tests before and after using PGO in MySQL 8.0.27 under SMP.
30 |
31 | [Next](Chapter4_6.md)
32 |
--------------------------------------------------------------------------------
/Chapter4_6.md:
--------------------------------------------------------------------------------
1 | ## 4.6 Queueing Theory
2 |
3 | Queueing theory is the mathematical study of waiting lines or queues, used to predict queue lengths and waiting times [45]. It is widely applied in computer science and information technology. For example, in networking, routers and switches rely on queues to manage packet transmission. By applying queueing theory, designers can optimize these systems for responsive performance and efficient resource utilization. Although queueing theory is not specifically designed to improve software performance, it serves as a model for evaluating system efficiency by examining how resources, both physical and logical, are utilized. According to queueing theory, almost any resource can be viewed as a queue, and bottleneck resources can be analyzed this way to better understand their characteristics.
4 |
5 | ### 4.6.1 Single Queue Bottleneck
6 |
7 | The following figure depicts a scenario where MySQL primary and MySQL secondary form a two-node cluster under a network latency of 10ms.
8 |
9 | 
10 |
11 | Figure 4-23. Testing architecture for Group Replication with modified Mencius protocol.
12 |
13 | The cluster's Paxos algorithm employs a modified Mencius approach, removing batching and pipelining, making it similar to pure Paxos. Tests were conducted at various concurrency levels under a network latency of 10ms, as illustrated in the following figure:
14 |
15 | 
16 |
17 | Figure 4-24. Results of testing Group Replication with modified Mencius protocol.
18 |
19 | In a WAN testing scenario, the throughput remains nearly constant across different concurrency levels—50, 100, or 150—because the time MySQL takes to process TPC-C transactions is negligible compared to the network latency of 10ms. This network latency dominates the overall transaction time, making the impact of concurrency changes relatively insignificant.
20 |
21 | The throughput calculation formula in such scenarios simplifies to:
22 |
23 | 
24 |
25 | This closely matches the test results above, where 0.45 is an empirical factor derived from extensive testing that represents the ratio of tpmC to tpmTOTAL. The tests indicate that, under a 10ms network latency with no additional bottlenecks, throughput remains consistent across different concurrency levels. This consistency is due to the serial nature of Paxos communication, as batching and pipelining are not employed. Confirmation of these findings is supported by packet capture analysis.
26 |
27 | 
28 |
29 | Figure 4-25. Insights into the modified Mencius protocol from packet capture data.
30 |
31 | In the figure, the network latency between the two Paxos instances is approximately 10ms, matching the exact network delay. Numerous examples suggest that Paxos communication is inherently serial. In scenarios where network latency is the predominant factor, it acts as a single queue bottleneck. Consequently, regardless of concurrency levels, the throughput of modified Mencius is limited by this network latency.
32 |
33 | ### 4.6.2 Multiple Queue Bottlenecks
34 |
35 | A complex program often involves multiple queues, and unless one queue dominates, several bottlenecks can exist simultaneously. The figure below illustrates a basic server queue model with a single CPU and two disks. When the CPU is busy, requests are queued, and the same happens when accessing the disks. In this model, queueing theory can be applied to calculate the server's throughput capacity.
36 |
37 | 
38 |
39 | Figure 4-26. A basic server queue model with single CPU and dual Disks.
40 |
41 | In modern NUMA environments with abundant CPUs and cross-NUMA access interference, directly calculating system throughput using queueing theory can be challenging. For instance, the following figure illustrates the latch queue model of MySQL 5.7.
42 |
43 | 
44 |
45 | Figure 4-27. The latch queue model in MySQL 5.7.
46 |
47 | This involves the latch queue bottlenecks within the InnoDB storage engine, a significant scalability problem in MySQL 5.7. In this queue model, addressing individual bottlenecks alone is insufficient to solve scalability problems, and accurately assessing the impact of these queue bottlenecks on throughput remains challenging.
48 |
49 | ### 4.6.3 The Mutual Influence Between Different Queue Bottlenecks
50 |
51 | The following figure is a simplified example of a multi-queue model in a NUMA environment.
52 |
53 | 
54 |
55 | Figure 4-28. A multi-queue model in a NUMA Environment.
56 |
57 | In the case of 100 concurrent threads, the latch1 queue can handle 2,000 requests per second. However, with 500 concurrent threads, its throughput drops to only 200 requests per second. This discrepancy arises because increased conflicts lead to significant context switching, causing cache content to migrate across NUMA nodes, which sharply reduces memory access efficiency. As concurrency rises, this inefficiency grows, leading to a notable decline in throughput.
58 |
59 | Under normal conditions, with 100 concurrent threads passing through latch1, 10 threads typically proceed to latch2 and another 10 to latch3. Both latch2 and latch3 can handle 300 requests per second with 10 concurrent threads, meaning that no bottlenecks are encountered.
60 |
61 | When 500 concurrent threads interact with latch1, the increased conflicts result in fewer requests successfully passing through, leading to reduced throughput. After identifying and optimizing latch1 (as shown in the figure below), its throughput capacity increased significantly: it can now handle 1,000 requests per second with 500 concurrent threads. This optimization has effectively mitigated the previous performance degradation caused by latch1 conflicts.
62 |
63 | 
64 |
65 | Figure 4-29. A multi-queue model mitigating latch1 bottleneck in NUMA environments.
66 |
67 | With 500 concurrent threads reaching the latch1 queue, the improved processing efficiency allows 50 threads to progress to latch2 and another 50 to latch3. However, severe conflicts at both latch2 and latch3 reduce their processing capacities to just 25 and 30 requests per second, respectively. This disrupts the balance of latch2 and latch3 queues, which were stable before optimizing latch1.
68 |
69 | In the scenario of multi-queue bottlenecks, optimizing one bottleneck may not necessarily lead to an increase in overall throughput; it could potentially even decrease throughput. Real-life examples of this include instances where Profile-Guided Optimization (PGO) led to decreased throughput under high concurrency, illustrating this phenomenon.
70 |
71 | Let's review again the throughput situation under high concurrency after applying PGO:
72 |
73 | 
74 |
75 | Figure 4-30. Performance comparison tests before and after using PGO in MySQL 8.0.27.
76 |
77 | Profile-Guided Optimization (PGO) accelerates CPU computation efficiency, enabling a larger number of threads to enter the latch queue earlier under high concurrency. This exacerbates latch conflicts compared to the pre-optimization state, leading to decreased throughput. Interestingly, when PGO is disabled, throughput decreases under low concurrency but increases under high concurrency. This counterintuitive phenomenon is common when multi-queue bottlenecks coexist.
78 |
79 | Let's examine the performance comparison before and after redo log optimization:
80 |
81 | 
82 |
83 | Figure 4-31. Performance comparison tests before and after redo log optimization in MySQL 8.0.
84 |
85 | The figure shows that performance improves under low concurrency but decreases under high concurrency. This repeatedly tested phenomenon indicates that not all optimizations show immediate results; eliminating disturbances is crucial to observe true effectiveness. These problems often occur in NUMA environments, so mitigating NUMA compatibility problems is essential to avoid misjudgments in performance optimization. Developers' reliance on data can overlook the real reasons for performance declines, leading to missed optimization opportunities.
86 |
87 | ### 4.6.4 The Relationship Between Resource Utilization and Response Time
88 |
89 | According to queueing theory, as resource utilization increases, average response time also increases, and as utilization approaches 100%, average response time deteriorates sharply. The following figure shows concurrent tests on CPU resources using SysBench, displaying the relationship between average response time and CPU utilization. Initially, the average response time increases slowly. However, around 60% CPU utilization, the curve sharply rises, reaching over 13 milliseconds at 96% utilization.
90 |
91 | 
92 |
93 | Figure 4-32. Relationship between average response time and CPU utilization.
94 |
95 | If resources are depleted, such as running out of memory, the machine's response time can become very slow. Therefore, controlling resource utilization is essential. According to queueing theory, for MySQL OLTP systems, maintaining response times requires keeping utilization within certain limits. Finding the optimal utilization point is crucial to maintain efficiency, which is the basis of transaction throttling theory. While queueing theory doesn't directly solve problems, it provides guidance for performance optimization and deepens the understanding of system performance.
96 |
97 | ### 4.6.5 Transaction Throttling Mechanism
98 |
99 | To prevent performance degradation, controlling resource usage is crucial. For MySQL OLTP applications, managing concurrency entering the transaction system is key due to multiple latch queue bottlenecks and the replication of global active transaction lists.
100 |
101 | A practical transaction throttling mechanism for MySQL is as follows:
102 |
103 | 1. Before entering the transaction system, check if the number of concurrent processing threads exceeds the limit.
104 | 2. If the limit is exceeded, block the user thread until other threads activate this thread.
105 | 3. If the limit is not exceeded, allow the thread to proceed with processing within the transaction system.
106 | 4. Upon transaction completion, activate the first transaction in the waiting queue.
107 |
108 | This approach helps maintain performance by controlling concurrency and managing resource usage effectively. The following figure illustrates the relationship between TPC-C throughput and concurrency under transaction throttling conditions, with 1000 warehouses.
109 |
110 | 
111 |
112 | Figure 4-33. Maximum TPC-C throughput in BenchmarkSQL with transaction throttling mechanisms.
113 |
114 | From the figure, it is evident that implementing transaction throttling mechanisms significantly improves MySQL's scalability.
115 |
116 | [Next](Chapter4_7.md)
117 |
--------------------------------------------------------------------------------
/Chapter4_9.md:
--------------------------------------------------------------------------------
1 | ## 4.9 Distributed Theory
2 |
3 | A MySQL cluster functions as a distributed database, governed by principles of distributed theory such as the CAP theorem and consistency.
4 |
5 | ### 4.9.1 CAP Theorem
6 |
7 | A distributed database has three very desirable properties:
8 |
9 | 1\. Tolerance towards Network Partition
10 |
11 | 2\. Consistency
12 |
13 | 3\. Availability
14 |
15 | The CAP theorem states: You can have at most two of these properties for any shared-data system
16 |
17 | Theoretically there are three options:
18 |
19 | 1. Forfeit Partition Tolerance
20 |
21 | The system does not have a defined behavior in case of a network partition.
22 |
23 | 2. Forfeit Consistency
24 |
25 | In case of partition data can still be used, but since the nodes cannot communicate with each other there is no guarantee that the data is consistent.
26 |
27 | 3. Forfeit Availability
28 |
29 | Data can only be used if its consistency is guaranteed, which implies the need for pessimistic locking. This requires locking any updated object until the update has been propagated to all nodes. In the event of a network partition, it may take a considerable amount of time for the database to return to a consistent state, thereby compromising the guarantee of high availability.
30 |
31 | Forfeiting Partition Tolerance is not feasible in realistic environments, as network partitions are inevitable. Therefore, it becomes necessary to make a choice between Availability and Consistency [20].
32 |
33 | The proof process of the CAP theorem is a typical example of logical reasoning. The specific proof process is described below [20]:
34 |
35 | ```
36 | First Gilbert and Lynch defined the three properties:
37 |
38 | 1. Consistency (atomic data objects)
39 | A total order must exist on all operations such that each operation looks as if it were completed at a single instance. For distributed shared memory this means (among other things) that all read operations that occur after a write operation completes must return the value of this (or a later) write operation.
40 |
41 | 2. Availability
42 | Every request received by a non-failing node must result in a response. This means, any algorithm used by the service must eventually terminate.
43 |
44 | 3. Partition Tolerance
45 | The network is allowed to lose arbitrarily many messages sent from one node to another.
46 |
47 | With this definition, the theorem was proven by contradiction:
48 |
49 | Assume all three criteria (atomicity, availability and partition tolerance) are fulfilled. Since any network with at least two nodes can be divided into two disjoint, non-empty sets {G1,G2}, we define our network as such. An atomic object o has the initial value v0. We define a1 as part of an execution consisting of a single write on the atomic object to a value v1 ≠ v0 in G1. Assume a1 is the only client request during that time. Further, assume that no messages from G1 are received in G2, and vice versa.
50 |
51 | Because of the availability requirement we know that a1 will complete, meaning that the object o now has value v1 in G1.
52 |
53 | Similarly a2 is part of an execution consisting of a single read of o in G2. During a2 again no messages from G2 are received in G1 and vice versa. Due to the availability requirement we know that a2 will complete.
54 |
55 | If we start an execution consisting of a1 and a2, G2 only sees a2 since it does not receive any messages or requests concerning a1. Therefore the read request from a2 still must return the value v0. But since the read request starts only after the write request ended, the atomicity requirement is violated, which proves that we cannot guarantee all three requirements at the same time. q.e.d.
56 | ```
57 |
58 | Understanding the CAP theorem lays a foundation for comprehending problems in distributed systems. For instance, in a Group Replication cluster, achieving strong consistency on every node may require sacrificing availability. The "after" mechanism of Group Replication can meet this requirement. Conversely, prioritizing availability means that during network partitions, MySQL secondaries might read stale data since distributed consistency in reads cannot be guaranteed.
59 |
60 | ### 4.9.2 Read Consistency
61 |
62 | MySQL secondaries can handle read tasks, but they may not keep up with the pace of the MySQL primary. This can lead to problems with read consistency.
63 |
64 | In a distributed environment, the paper "Replicated Data Consistency Explained Through Baseball" [37] describes various types of read operation consistency. Below is a detailed outline of common types of read operation consistency.
65 |
66 | 
67 |
68 | Figure 4-67. Common types of read operation consistency.
69 |
70 | The figure describes the three most common types of consistency: strong consistency, read-your-writes consistency, and eventual consistency. The pattern observed is that the stronger the consistency, the poorer the performance, and the lower the availability.
71 |
72 | When reading data from multiple MySQL secondaries, various consistency read problems can easily arise. These can be mitigated using MySQL proxies. For instance, for the same user session, read operations can be directed to a single MySQL secondary. If the data on that MySQL secondary is not up-to-date, the operation waits, thus avoiding typical consistency read problems.
73 |
74 | MySQL has made significant efforts to ensure consistent reads in clustered environments. During MySQL secondary replay, it is crucial to maintain the transaction commit order consistent with the relay log entry order. This means that a transaction can only commit once all preceding transactions have been committed. The **replica_preserve_commit_order** parameter in MySQL helps enforce this constraint.
75 |
76 | To effectively mitigate consistency read problems, MySQL secondaries should ideally keep up with the pace of the MySQL primary. If the MySQL primary and its secondaries operate at similar speeds, users can quickly access the most recent data from the secondaries. Therefore, combining fast replay on MySQL secondaries with addressing consistency read problems can significantly ease these challenges.
77 |
78 | ### 4.9.3 Consensus
79 |
80 | For decades, the Paxos algorithm has been synonymous with distributed consensus. Despite its widespread deployment in production systems, Paxos is often misunderstood and proves to be heavyweight, unscalable, and unreliable in practice. Extensive research has been conducted to better understand the algorithm, optimize its performance, and mitigate its limitations [29]. Over time, numerous variants of Paxos have emerged, each tailored to different application scenarios based on majority-based consensus. It is important to keep these variants distinct.
81 |
82 | For example, Group Replication in MySQL supports both single-primary and multi-primary modes, requiring consistent read and write operations in single-primary mode. This necessitates a multi-leader Paxos algorithm for consensus. The MySQL's original Mencius algorithm faced performance problems in certain scenarios, leading to the introduction of a single-leader Multi-Paxos algorithm to address these concerns. Maintaining two different variants of the Paxos algorithm simultaneously poses challenges in code maintenance, and numerous regression problems discovered later have validated this viewpoint.
83 |
84 | ### 4.9.4 Distributed Transaction
85 |
86 | In MySQL, the XA protocol can be used to implement the two-phase commit protocol, ensuring atomicity in distributed environments. Many database products use XA to implement distributed transactions with various transaction isolation levels. However, response times in this context are often not ideal.
87 |
88 | As highlighted in "Designing Data-Intensive Applications" [28]: "XA has poor fault tolerance and performance characteristics, which severely limit its usefulness." MySQL XA transactions not only negatively impact response times but also pose challenges for MySQL secondary replay. The second phase of an XA transaction depends on the first phase, affecting concurrent replay on MySQL secondaries, as different phases must proceed serially.
89 |
90 | Therefore, it is advisable for MySQL users to avoid XA transactions when possible. It's important to note that while the XA two-phase commit protocol bears some similarities to Paxos algorithms, the XA protocol cannot utilize batching techniques and requires all participants to agree before proceeding with subsequent operations.
91 |
92 | [Next](Chapter4_10.md)
93 |
--------------------------------------------------------------------------------
/Part1.md:
--------------------------------------------------------------------------------
1 | # Part1 Problems
2 |
3 | This part focuses entirely on MySQL-related problems. Chapter 1 explores how users approach and solve challenging MySQL problems. Chapter 2 focuses on mysterious problems in MySQL 8.0.
4 |
5 | [Next](Chapter1.md)
6 |
--------------------------------------------------------------------------------
/Part2.md:
--------------------------------------------------------------------------------
1 | # Part2 Basics
2 |
3 | This part primarily covers the fundamental knowledge related to problem-solving. Chapter 3 emphasizes the importance of logical reasoning skills in addressing MySQL challenges effectively. Chapter 4 provides practical computer fundamentals essential for understanding MySQL problems. Chapter 5 introduces MySQL kernel basics, laying the groundwork for subsequent problem-solving discussions. Chapter 6 covers scientific methods for testing MySQL.
4 |
5 | [Next](Chapter3.md)
6 |
--------------------------------------------------------------------------------
/Part3.md:
--------------------------------------------------------------------------------
1 | # Part3 Analyzing and Addressing MySQL Problems
2 |
3 | This part focuses on analyzing and addressing specific problems. Chapter 7 highlights notable optimizations in MySQL 8.0, while Chapter 8 examines improvements for solving problems specific to MySQL 8.0. Chapter 9 discusses enhancements in MySQL Group Replication, and Chapter 10 covers improvements in MySQL secondary replay. Together, these chapters enhance MySQL performance and lay the groundwork for achieving a high-availability cluster.
4 |
5 | [Next](Chapter7.md)
6 |
--------------------------------------------------------------------------------
/Part4.md:
--------------------------------------------------------------------------------
1 | # Part 4 Tuning
2 |
3 | This part primarily analyzes performance improvements from the perspective of MySQL users.
4 |
5 | [Next](Chapter11.md)
6 |
--------------------------------------------------------------------------------
/Part5.md:
--------------------------------------------------------------------------------
1 | # Part 5 Conclusion
2 |
3 | This Part provides the concluding summary, outlines future directions for MySQL improvements, and wraps up the book.
4 |
5 | [Next](Chapter12.md)
6 |
--------------------------------------------------------------------------------
/Preface.md:
--------------------------------------------------------------------------------
1 | # Preface
2 |
3 | ## Who This Book Is For?
4 |
5 | When software professionals encounter complex problems, they often face contradictions and struggle to find solutions. To overcome these challenges, it's crucial to view tough problems as opportunities for significant rewards. Embracing difficult challenges can lead to valuable insights and breakthroughs.
6 |
7 | With 20 years of problem-solving experience, most challenging problems in server-side software can be solved through systematic logical analysis. Despite its global prominence, MySQL faces a variety of problems. The journey in addressing these MySQL problems has enriched understanding and led to the development of unique insights, which inspired the writing of this book.
8 |
9 | This book uses MySQL challenges as case studies to explore problem analysis and resolution strategies. Readers will gain a deeper appreciation for logical reasoning, data structures, algorithms, and more through practical examples and insightful discussions.
10 |
11 | This book covers the following topics:
12 |
13 | 1. **Logical Reasoning for MySQL**: Techniques for analyzing complex MySQL problems using logical reasoning.
14 | 2. **Computer Science Fundamentals**: Fundamentals of computer science relevant to MySQL.
15 | 3. **MySQL Internals**: An introduction to the basics of MySQL core components.
16 | 4. **Performance Testing**: Methods for scientifically testing MySQL performance.
17 | 5. **MySQL 8.0 Improvements**: Key improvements in MySQL 8.0 compared to MySQL 5.7.
18 | 6. **MySQL Improvements**: Further optimizations in a standalone MySQL instance.
19 | 7. **Group Replication Advancements**: Notable enhancements in MySQL Group Replication.
20 | 8. **Secondary Replay improvements**: Optimizations in MySQL's secondary replay.
21 | 9. **Performance Optimization Techniques**: Strategies for optimizing MySQL applications.
22 |
23 | **Focus of the Book:**
24 |
25 | Building on the goal of enhancing MySQL scalability, this book explores various optimization strategies to increase throughput, reduce response times, and ensure that MySQL secondaries closely match the performance of the primary server, thereby achieving high availability failover with very little delay in most scenarios.
26 |
27 | **Target Audience:**
28 |
29 | 1. **Quality-Focused Developers**: Individuals committed to high-quality software development.
30 | 2. **Problem Solvers**: Those interested in tackling complex software problems.
31 | 3. **MySQL Enthusiasts**: Readers looking to understand MySQL from the ground up.
32 | 4. **Testing Practitioners**: Users keen on mastering effective testing techniques.
33 | 5. **Software Architects**: Those designing large-scale software systems.
34 | 6. **Performance Engineers**: Engineers struggling with performance optimization.
35 | 7. **Computer Science Students**: Learners aiming to strengthen their foundational knowledge.
36 | 8. **MySQL Researchers**: Researchers conducting studies based on MySQL.
37 |
38 | ## Outline of This Book
39 |
40 | Part 1 focuses entirely on MySQL-related problems. Chapter 1 explores how users approach and solve challenging MySQL problems. Chapter 2 focuses on mysterious problems in MySQL 8.0.
41 |
42 | Part 2 primarily covers the fundamental knowledge related to problem-solving. Chapter 3 emphasizes the importance of logical reasoning skills in addressing MySQL challenges effectively. Chapter 4 provides practical computer fundamentals essential for understanding MySQL problems. Chapter 5 introduces MySQL kernel basics, laying the groundwork for subsequent problem-solving discussions. Chapter 6 covers scientific methods for testing MySQL.
43 |
44 | Part 3 primarily focuses on the analysis and improvement of specific problems. Chapter 7 highlights notable optimizations in MySQL 8.0. Chapter 8 examines improvements for solving problems specific to MySQL 8.0. Chapter 9 discusses enhancements in MySQL Group Replication, while Chapter 10 focuses on improvements in MySQL secondary replay. Together, these chapters not only boost MySQL performance but also lay the foundation for achieving a high availability cluster.
45 |
46 | Part 4 primarily analyzes performance improvements from the perspective of MySQL users. Chapter 11 presents techniques to improve MySQL 8.0 application performance without code changes.
47 |
48 | Part 5 is the concluding summary. Chapter 12 outlines future directions for MySQL improvements and concludes the book.
49 |
50 | ## References and Further Reading
51 |
52 | This book focuses on analyzing and solving MySQL problems, so a certain level of computer science background is recommended. To support understanding and maintain continuity, key terminology is included in the "Glossary" section of the appendix. For those lacking a foundation in MySQL, please refer to the related content in the appendix or consult [dedicated MySQL books](https://github.com/enhancedformysql/tech-explorer-hub) [69].
53 |
54 | ## Special Terminology Explanation
55 |
56 | 1. **Balanced Replay Speed**
57 |
58 | For MySQL secondary replay, this defines balanced replay speed where the MySQL secondary matches the primary under normal circumstances. When the speed is at or below the balanced replay speed, there is no significant lag in transaction replay progress on the secondary. However, if the speed exceeds this threshold, the secondary begins to lag behind the primary in transaction replay progress.
59 |
60 | 2. **Dual One**
61 |
62 | Specifically refers to two major configurations in MySQL: *sync_binlog=1* and *innodb_flush_log_at_trx_commit=1*.
63 |
64 | 3. **MySQL Secondary Replay**
65 |
66 | This term represents the common replay process for asynchronous replication, semisynchronous replication, and Group Replication. In this book, 'MySQL primary' is consistently used to represent the MySQL source, and 'MySQL secondary' to represent the MySQL replica.
67 |
68 | ## Deployment Supplementary Explanation
69 |
70 | When deploying MySQL for testing, it is preferable to match the test environment as closely as possible to the production environment, unless certain configurations significantly interfere with performance analysis. Below are specific declarations related to MySQL deployment during the testing process:
71 |
72 | 1. The mainstream servers in use all have a 4-way NUMA architecture.
73 | 2. Servers are generally x86 architecture.
74 | 3. NVMe SSD hardware disks are used, and the I/O latency is very low.
75 | 4. All tests were conducted on high-performance servers and only represent results for high-performance server configurations.
76 | 5. All tests are conducted on the Linux operating system.
77 | 6. MySQL standalone tests typically use version 8.0.27, while MySQL cluster tests generally use version 8.0.32.
78 | 7. Improvements to MySQL are referred to as improved MySQL or modified MySQL.
79 | 8. The transaction isolation level in TPC-C tests is *Read Committed*.
80 | 9. The storage engine used for transactions is InnoDB.
81 | 10. Unless otherwise stated, the default mode during MySQL Group Replication testing is single-primary mode.
82 | 11. The *binlog_format* parameter is set to row-based format.
83 | 12. MySQL, whether primary or secondary, uses GTID (Global Transaction Identifier).
84 | 13. Cluster settings include *replica_preserve_commit_order=on*.
85 | 14. Most tests are based on BenchmarkSQL TPC-C.
86 | 15. Unless stated otherwise, TPC-C tests are generally based on partitioned large tables.
87 | 16. Due to the extensive number of tests, the related software, hardware, and configurations are detailed in the Appendix.
88 |
89 | ## How to Contact Us
90 |
91 | For configurations, patches, and additional information related to this book, please visit our webpage: .
92 |
93 | Email [wangbin579@gmail.com](mailto:wangbin579@gmail.com) to comment or ask technical questions about this book.
94 |
95 | ## Acknowledgments
96 |
97 | This book meticulously organizes a wealth of ideas and knowledge contributed by numerous individuals, encompassing insights from both academic research and industrial practice. In computing, there is a natural inclination towards the latest innovations, yet our historical foundations offer valuable lessons. This book references dozens of articles, blog posts, documentation, and other resources, making it an invaluable learning resource for me. I am profoundly grateful to the authors for their generous contributions of knowledge.
98 |
99 | Several individuals have been crucial in the writing of this book by reviewing drafts and offering feedback. I am especially grateful for the contributions of Hongshen Wang, Jinrong Ye, Riyao Gao, and Haitao Gao. Naturally, I take full responsibility for any remaining errors or contentious opinions in this book.
100 |
101 | Finally, my deepest gratitude to my family, whose unwavering support has been indispensable throughout this nearly six-month writing journey. You are the best.
102 |
103 | [Next](Part1.md)
104 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ## The Art of Problem-Solving in Software Engineering:How to Make MySQL Better
2 |
3 | ### Introduction
4 |
5 | This book uses MySQL challenges as case studies to explore problem analysis and resolution strategies. Readers will gain a deeper appreciation for logical reasoning, data structures, algorithms, and more through practical examples and insightful discussions.
6 |
7 | ### Table of Contents
8 |
9 | [Preface](Preface.md)
10 |
11 | [Part1 Problems](Part1.md)
12 |
13 | [Chapter 1: Traditional Methods for Solving MySQL Problems](Chapter1.md)
14 |
15 | [Chapter 2: Mysterious MySQL Problems](Chapter2.md)
16 |
17 | [Part2 Basics](Part2.md)
18 |
19 | [Chapter 3: How to Solve Software Problems Effectively](Chapter3.md)
20 |
21 | [Chapter 4: Fundamentals of Computer Science](Chapter4.md)
22 |
23 | [Chapter 5: MySQL Internals](Chapter5.md)
24 |
25 | [Chapter 6: How to Scientifically Test MySQL Performance?](Chapter6.md)
26 |
27 | [Part3 Analyzing and Addressing MySQL Problems](Part3.md)
28 |
29 | [Chapter 7: Key Improvements of MySQL 8.0 Over MySQL 5.7](Chapter7.md)
30 |
31 | [Chapter 8: Refining MySQL 8.0: Next-Level Improvements](Chapter8.md)
32 |
33 | [Chapter 9: Major Enhancements in Group Replication](Chapter9.md)
34 |
35 | [Chapter 10: Major Improvements for MySQL Secondary Replay](Chapter10.md)
36 |
37 | [Part4 Tuning](Part4.md)
38 |
39 | [Chapter 11: Performance Tuning](Chapter11.md)
40 |
41 | [Part5 Conclusion](Part5.md)
42 |
43 | [Chapter 12: Future Directions](Chapter12.md)
44 |
45 | [References](References.md)
46 |
47 | [Appendix](Appendix.md)
48 |
49 | ### Errata
50 |
51 | If you find any errata in the book, [please open a new issue](https://github.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/issues).
52 |
53 | ### **Prerequisite reading**
54 |
55 | [Computer Science Basics](https://enhancedformysql.github.io/tech-explorer-hub/reading/computer-basics/index.html)
56 |
57 | [High Performance MySQL](https://enhancedformysql.github.io/tech-explorer-hub/reading/database/mysql.html)
58 |
59 | [Architecture of a Database System](https://enhancedformysql.github.io/tech-explorer-hub/reading/database/database_architecture.html)
60 |
61 | ### Access the Book on GitHub Pages
62 |
63 | [Online URL](https://enhancedformysql.github.io/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/)
64 |
65 | ### Copyright
66 |
67 | Copyright © wangbin579 2025. All rights reserved.
68 |
--------------------------------------------------------------------------------
/References.md:
--------------------------------------------------------------------------------
1 | # References
2 |
3 | [1] Zeitz, P. (1999). The art and craft of problem solving. New York: John Wiley.
4 |
5 | [2] C. Mohan, D.L. Haderle, B. Lindsay, H. Pirahesh, and P. Schwarz. ARIES: A transaction recovery method supporting fine-granularity locking and partial rollbacks using write-ahead logging. ACM TODS, 17 (1): 94--162, 1992.
6 |
7 | [3] Johnson, R., et al. Scalability of write-ahead logging on multicore and multisocket hardware. VLDBJ, pp. 239--263, 2012.
8 |
9 | [4] Collin McCurdy and Jeffrey Vetter. 2010. Memphis: Finding and fixing NUMA-related performance problems on multi-core platforms. In IEEE International Symposium on Performance Analysis of Systems 8 Software (ISPASS'10). 87--96.
10 |
11 | [5] T. Kiefer, B. Schlegel, and W. Lehner. Experimental evaluation of NUMA effects on database management systems. In BTW, 2013.
12 |
13 | [6] A. Alquraan, H. Takruri, M. Alfatafta, and S. Al-Kiswany. An analysis of network-partitioning failures in cloud systems. In Proceedings of the 13th USENIX Conference on Operating Systems Design and Implementation, OSDI'18, pages 51--68, Carlsbad, CA, USA, 2018. USENIX Association.
14 |
15 | [7] Adnan Alhomssi and Viktor Leis. 2023. Scalable and Robust Snapshot Isolation for High-Performance Storage Engines. Proc. VLDB Endow. 16, 6 (2023), 1426–1438.
16 |
17 | [8] Y. Wang, M. Yu, Y. Hui, F. Zhou, Y. Huang, R. Zhu, et al.. 2022. A study of database performance sensitivity to experiment settings, Proceedings of the VLDB Endowment, vol. 15, no. 7.
18 |
19 | [9] M. Raasveldt, P. Holanda, T. Gubner, and H. Muhleisen. Fair Benchmarking Considered Difficult: Common Pitfalls In Database Performance Testing. In 7th International Workshop on Testing Database Systems, DBTest, 2:1--2:6, 2018.
20 |
21 | [10] M. Harchol-Balter. Performance Modeling and Design of Computer Systems: Queueing Theory in Action. Cambridge University Press, New York, NY, USA, 1st edition, 2013.
22 |
23 | [11] Hao Xu, Qingsen Wang, Shuang Song, Lizy Kurian John, and Xu Liu. 2019. Can we trust profiling results? Understanding and fixing the inaccuracy in modern profilers. In Proceedings of the ACM International Conference on Supercomputing. 284–295.
24 |
25 | [12] T. Mytkowicz, A. Diwan, M. Hauswirth, and P. F. Sweeney. Evaluating the accuracy of Java profilers. In PLDI, pages 187--197. ACM, 2010.
26 |
27 | [13] https://dev.mysql.com/doc/refman/8.0/en/.
28 |
29 | [14] Alibaba Cloud. 2019. OceanBase Did Better than Any Other Database in the TPC-C Benchmark. alibaba-cloud.medium.com.
30 |
31 | [15] B. H. Dowden, Logical reasoning (California State University, Sacramento, CA, 2019).
32 |
33 | [16] C. Hong, D. Zhou, M. Yang, C. Kuo, L. Zhang, and L. Zhou. KuaFu: Closing the parallelism gap in database replication. In Proc. ICDE 2013, pages 1186--1195, 2013.
34 |
35 | [17] I. Psaroudakis, T. Scheuer, N. May, and A. Ailamaki. Task scheduling for highly concurrent analytical and transactional main-memory workloads. In ADMS Workshop, 2013.
36 |
37 | [18] Dai Qin, Angela Demke Brown, and Ashvin Goel. 2017. Scalable replay-based replication for fast databases. Proceedings of the VLDB Endowment (2017).
38 |
39 | [19] H. Jung, H. Han, A. D. Fekete, G. Heiser, and H. Y. Yeom. A scalable lock manager for multicores. In SIGMOD, 2013.
40 |
41 | [20] Simon, S.: Brewer's CAP Theorem. CS341 Distributed Information Systems, University of Basel (HS2012).
42 |
43 | [21] Harizopoulos, S. and Ailamaki, A. 2003. A case for staged database systems. In Proceedings of the Conference on Innovative Data Systems Research (CIDR). Asilomar, CA. Harizopoulos, S. and Ailamaki, A. 2003. A case for staged database systems. In Proceedings of the Conference on Innovative Data Systems Research (CIDR). Asilomar, CA.
44 |
45 | [22] Xiangyao Yu. An evaluation of concurrency control with one thousand cores. PhD thesis, Massachusetts Institute of Technology, 2015.
46 |
47 | [23] K. Ren, J. M. Faleiro, and D. J. Abadi. Design principles for scaling multi-core OLTP under high contention. In Proceedings of the 2016 ACM SIGMOD International Conference on Management of Data, 2016.
48 |
49 | [24] B. Tian, J. Huang, B. Mozafari, and G. Schoenebeck. Contention-aware lock scheduling for transactional databases. PVLDB, 11(5), 2018.
50 |
51 | [25] Peter Bailis, Alan Fekete, Michael J. Franklin, Ali Ghodsi, Joseph M. Hellerstein, and Ion Stoica. 2014. Coordination avoidance in database systems. Proc. VLDB Endow. 3 (Nov. 2014), 185--196.
52 |
53 | [26] J. Rao, E. J. Shekita, and S. Tata. Using paxos to build a scalable, consistent, and highly available datastore. VLDB, 2011.
54 |
55 | [27] [Paweł Olchawa](https://dev.mysql.com/blog-archive/?author=Pawe%C5%82%20Olchawa). 2018. MySQL 8.0: New Lock free, scalable WAL design. dev.mysql.com/blog-archive.
56 |
57 | [28] Martin Kleppmann. Designing Data-Intensive Applications. English. 1 edition. O'Reilly Media, Jan. 2017. ISBN: 978-1-4493-7332-0.
58 |
59 | [29] Heidi Howard. Distributed consensus revised. PhD thesis, University of Cambridge, 2019. URL: https://www.cl.cam.ac.uk/techreports/UCAM-CL-TR-935.pdf.
60 |
61 | [30] Chandra, T.D., Griesemer, R., Redstone, J.: Paxos Made Live: An Engineering Perspective. In: Proceedings of the Twenty-sixth Annual ACM Symposium on Principles of Distributed Computing, New York, USA: ACM, pp. 398–407, (2007).
62 |
63 | [31] https://dev.mysql.com/blog-archive/the-new-mysql-thread-pool/.
64 |
65 | [32] Y. Mao, F. P. Junqueira, and K. Marzullo. Mencius: building efficient replicated state machines for WANs. In Proc. 8th USENIX OSDI, pages 369--384, San Diego, CA, Dec. 2008.
66 |
67 | [33] C. Millsap. Thinking Clearly About Performance, Queue, vol. 8, no. 9, pp. 10-20, 2010.
68 |
69 | [34] Leonidas Galanis, Supiti Buranawatanachoke, Romain Colle, [Benoît Dageville](https://dblp.org/pid/59/847.html), Karl Dias, Jonathan Klein, Stratos Papadomanolakis, Leng Leng Tan, Venkateshwaran Venkataramani, Yujun Wang, and Graham Wood. 2008. Oracle Database Replay. In Proceedings of the 2008 ACM SIGMOD International Conference on Management of Data. 1159--1170.
70 |
71 | [35] G. Moerkotte and T. Neumann. Dynamic programming strikes back. In Proceedings of the 2008 ACM SIGMOD international conference on Management of data, pages 539--552. ACM, 2008.
72 |
73 | [36] Suntorn Sae-eung. 2010. Analysis of false cache line sharing effects on multicore cpus, Master's Projects, vol. 01.
74 |
75 | [37] D. Terry. Replicated data consistency explained through baseball, Microsoft Technical Report MSR-TR-2011-137, October 2011. To appear in Communications of the ACM, December 2013.
76 |
77 | [38] Anirban Rahut, Abhinav Sharma, Yichen Shen, Ahsanul Haque. 2023. Building and deploying MySQL Raft at Meta. engineering.fb.com.
78 |
79 | [39] Taipalus T. Database management system performance comparisons: A systematic survey. Published online January 3, 2023. Accessed July 31, 2023. http://arxiv.org/abs/2301.01095.
80 |
81 | [40] Holger Pirk. 2022. https://co339.pages.doc.ic.ac.uk/decks/Profiling.pdf.
82 |
83 | [41] M Poke. 2019. Algorithms for High-Performance State-Machine Replication. DOCTORAL DISSERTATION. HELMUT SCHMIDT UNIVERSITY.
84 |
85 | [42] Ritwik Yadav and Anirban Rahut. 2023. FlexiRaft: Flexible Quorums with Raft. The Conference on Innovative Data Systems Research (CIDR) (2023).
86 |
87 | [43] Jung-Sang Ahn, Woon-Hak Kang, Kun Ren, Guogen Zhang, and Sami Ben-Romdhane. 2019. Designing an efficient replicated log store with consensus protocol. In 11th USENIX Workshop on Hot Topics in Cloud Computing (HotCloud 19).
88 |
89 | [44] Arunprasad P. Marathe, Shu Lin, Weidong Yu, Kareem El Gebaly, Per-Åke Larson, and Calvin Sun. 2022. Integrating the Orca Optimizer into MySQL. In Proceedings of the 25th International Conference on Extending Database Technology, EDBT 2022, Edinburgh, UK, March 29 - April 1, 2022. OpenProceedings.org, 2:511--2:523.
90 |
91 | [45] https://en.wikipedia.org/wiki/.
92 |
93 | [46] Urbán, P., Défago, X., Schiper, A.: Chasing the FLP impossibility result in a lan or how robust can a fault tolerant server be? In: 20th IEEE Symp. on Reliable Distributed Systems (SRDS), pp. 190–193. New Orleans, USA (2001).
94 |
95 | [47] https://www.candtsolution.com/news_events-detail/what-is-the-difference-between-arm-and-x86/.
96 |
97 | [48] N. Santos and A. Schiper. Tuning Paxos for high-throughput with batching and pipelining, in 13th International Conference on Distributed Computing and Networking (ICDCN 2012), Jan. 2012.
98 |
99 | [49] J. Kończak, N. Santos, T. Zurkowski, P. T. Wojciechowski, and A. Schiper. JPaxos: state machine replication based on the Paxos protocol. Technical report, EPFL, 2011.
100 |
101 | [50] R. N. Avula and C. Zou. Performance evaluation of TPC-C benchmark on various cloud providers, Proc. 11th IEEE Annu. Ubiquitous Comput. Electron. Mobile Commun. Conf. (UEMCON), pp. 226-233, Oct. 2020.
102 |
103 | [51] Guna Prasaad, Alvin Cheung, and Dan Suciu. 2018. Improving High Contention OLTP Performance via Transaction Scheduling. https://arxiv.org/abs/1810.01997v1.
104 |
105 | [52] Sergey Blagodurov and Alexandra Fedorova. 2011. User-level Scheduling on NUMA Multicore Systems under Linux. In in Proc. of Linux Symposium.
106 |
107 | [53] https://www.ibm.com/docs/en/linux-on-systems?topic=management-linux-scheduling.
108 |
109 | [54] Yanhua Mao. 2010. State Machine Replication for Wide Area Networks. Doctor of Philosophy in Computer Science. UNIVERSITY OF CALIFORNIA, SAN DIEGO.
110 |
111 | [55] Zhou, X., Chai, C., Li, G., Sun, J.: Database meets artificial intelligence: A survey. IEEE Transactions on Knowledge and Data Engineering (2020).
112 |
113 | [56] Prince Samuel. 2023. The Role of Logical Reasoning in Programming. medium.com.
114 |
115 | [57] Sunny Bains. 2017. Contention-Aware Transaction Scheduling Arriving in InnoDB to Boost Performance. https://dev.mysql.com/blog-archive/.
116 |
117 | [58] Andres Freund. 2020. Improving Postgres Connection Scalability: Snapshots. techcommunity.microsoft.com.
118 |
119 | [59] J. M. Hellerstein, M. Stonebraker, and J. R. Hamilton. Architecture of a database system. Foundations and Trends in Databases. 1(2) pp. 141--259, 2007.
120 |
121 | [60] Chuanpeng Li, Chen Ding, and Kai Shen. Quantifying the cost of context switch. In Proceedings of the 2007 workshop on Experimental computer science, ExpCS ’07, New York, NY, USA, 2007. ACM.
122 | [61] Xiangpeng Hao, Xinjing Zhou, Xiangyao Yu, and Michael Stonebraker. 2024. Towards Buffer Management with Tiered Main Memory. Proc. ACM Manag. Data 2, 1 (Feb. 2024), Article 31. SIGMOD.
123 |
124 | [62] Guoliang Jin, Linhai Song, Xiaoming Shi, Joel Scherpelz, and Shan Lu. 2012. Understanding and detecting real-world performance bugs. In ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI '12, Beijing, China - June 11 - 16, 2012. 77–88.
125 |
126 | [63] Jelena Antic, Georgios Chatzopoulos, Rachid Guerraoui, and Vasileios Trigonakis. 2016. Locking made easy. In Proceedings of the International Middleware Conference (Middleware). 1--14.
127 |
128 | [64] D. Dice and A. Kogan, "Avoiding scalability collapse by restricting concurrency" in Euro-Par 2019: Parallel Processing, Cham:Springer International Publishing, pp. 363-376, 2019.
129 |
130 | [65] https://github.com/session-replay-tools/tcpcopy.
131 |
132 | [66] https://github.com/session-replay-tools/cetus.
133 |
134 | [67] https://github.com/enhancedformysql/enhancedformysql.
135 |
136 | [68] https://github.com/enhancedformysql/benchmarksql.
137 |
138 | [69] https://github.com/enhancedformysql/tech-explorer-hub.
139 |
140 | [70] Graefe G (2010) A survey of B-tree locking techniques. ACM Trans Database Syst 35(3):16
141 |
142 | [71] Jean-Pierre Lozi, Baptiste Lepers, Justin Funston, Fabien Gaud, Vivien Quéma, and Alexandra Fedorova. The linux scheduler: A decade of wasted cores. In Proceedings of the Eleventh European Conference on Computer Systems, EuroSys '16, New York, NY, USA, 2016. Association for Computing Machinery.
143 |
144 | [Next](Appendix.md)
145 |
--------------------------------------------------------------------------------
/media/068e498c1a257071ce3004ad2d7b7ee3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/068e498c1a257071ce3004ad2d7b7ee3.png
--------------------------------------------------------------------------------
/media/08fb8a25d9542121b1e5b5ccb3cbdf6f.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/08fb8a25d9542121b1e5b5ccb3cbdf6f.gif
--------------------------------------------------------------------------------
/media/09cc60d64a306229adf9c4848d348c48.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/09cc60d64a306229adf9c4848d348c48.png
--------------------------------------------------------------------------------
/media/0e32e448841daf774e632cb0884cd7f4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/0e32e448841daf774e632cb0884cd7f4.png
--------------------------------------------------------------------------------
/media/12c296b6f5d91c71b24391af9c293363.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/12c296b6f5d91c71b24391af9c293363.png
--------------------------------------------------------------------------------
/media/149ca62fd014bd12b60c77573a49757d.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/149ca62fd014bd12b60c77573a49757d.gif
--------------------------------------------------------------------------------
/media/185beb2c6e0524d93abde3b25ecedc61.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/185beb2c6e0524d93abde3b25ecedc61.png
--------------------------------------------------------------------------------
/media/197c7662d3b25ebbc2870a1cee917e3f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/197c7662d3b25ebbc2870a1cee917e3f.png
--------------------------------------------------------------------------------
/media/19a92bf7065627b28a3403c000eba095.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/19a92bf7065627b28a3403c000eba095.png
--------------------------------------------------------------------------------
/media/1bb6230ef81aff3de4431206f0dbeed4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/1bb6230ef81aff3de4431206f0dbeed4.png
--------------------------------------------------------------------------------
/media/207ecb2302928ddf7ea58a6421ded46b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/207ecb2302928ddf7ea58a6421ded46b.png
--------------------------------------------------------------------------------
/media/22b839631e0b6d49bc9c5810488d9336.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/22b839631e0b6d49bc9c5810488d9336.png
--------------------------------------------------------------------------------
/media/22ed76b816248d0b27456d03e85bcea4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/22ed76b816248d0b27456d03e85bcea4.png
--------------------------------------------------------------------------------
/media/27e726f3ea50b5cabf751ee31a417b82.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/27e726f3ea50b5cabf751ee31a417b82.png
--------------------------------------------------------------------------------
/media/28708a58742f84033b84ff551cda3b1b.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/28708a58742f84033b84ff551cda3b1b.gif
--------------------------------------------------------------------------------
/media/290e969038561faf1ace6e108945b2d6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/290e969038561faf1ace6e108945b2d6.png
--------------------------------------------------------------------------------
/media/2e14f81ddb33dc7a1db1d7f41e69dcdd.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/2e14f81ddb33dc7a1db1d7f41e69dcdd.png
--------------------------------------------------------------------------------
/media/2eba13133f9eb007d89459cce5d4055b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/2eba13133f9eb007d89459cce5d4055b.png
--------------------------------------------------------------------------------
/media/3103134e2713f196cd4bd4242ef79f8e.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/3103134e2713f196cd4bd4242ef79f8e.png
--------------------------------------------------------------------------------
/media/331f4d2fe9b0d5939e8882a770592c94.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/331f4d2fe9b0d5939e8882a770592c94.png
--------------------------------------------------------------------------------
/media/363e8bb8f055a7611cb80e0c62b2fa2a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/363e8bb8f055a7611cb80e0c62b2fa2a.png
--------------------------------------------------------------------------------
/media/3a5d10caf25003e7ea4dcace59a181f6.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/3a5d10caf25003e7ea4dcace59a181f6.gif
--------------------------------------------------------------------------------
/media/3b2c3f6b25df292e0ed14955df4a7328.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/3b2c3f6b25df292e0ed14955df4a7328.png
--------------------------------------------------------------------------------
/media/3b54c6545f0c49be73fd3afd9c6ffe79.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/3b54c6545f0c49be73fd3afd9c6ffe79.gif
--------------------------------------------------------------------------------
/media/3efd7f636001d03ebf6fa17c39ae43b5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/3efd7f636001d03ebf6fa17c39ae43b5.png
--------------------------------------------------------------------------------
/media/42665a7506959bdefa1b451ce564a261.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/42665a7506959bdefa1b451ce564a261.png
--------------------------------------------------------------------------------
/media/4309ffee12d2eed2548845d1e1d2e848.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4309ffee12d2eed2548845d1e1d2e848.png
--------------------------------------------------------------------------------
/media/440f78c946a7e68fece427a41d414a2d.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/440f78c946a7e68fece427a41d414a2d.gif
--------------------------------------------------------------------------------
/media/468b1638646ec6ce6ae997ec6e52f152.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/468b1638646ec6ce6ae997ec6e52f152.png
--------------------------------------------------------------------------------
/media/47b077e25be1755b8c698aea97f51f7f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/47b077e25be1755b8c698aea97f51f7f.png
--------------------------------------------------------------------------------
/media/47c39411c3240713c75e848ef5ef4b59.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/47c39411c3240713c75e848ef5ef4b59.png
--------------------------------------------------------------------------------
/media/47f963cdd950abd91a459ffb66a3744e.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/47f963cdd950abd91a459ffb66a3744e.png
--------------------------------------------------------------------------------
/media/480170fff071f9764917821bb3a6ff6c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/480170fff071f9764917821bb3a6ff6c.png
--------------------------------------------------------------------------------
/media/48058e6b17b3f83cdc5479c38ad16648.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/48058e6b17b3f83cdc5479c38ad16648.png
--------------------------------------------------------------------------------
/media/484244432e5e53aff18ece6ad75eb616.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/484244432e5e53aff18ece6ad75eb616.png
--------------------------------------------------------------------------------
/media/4a72da4d419da7730675d64c4d060128.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4a72da4d419da7730675d64c4d060128.png
--------------------------------------------------------------------------------
/media/4a9ca333ba0b6b18acb7572285e92c26.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4a9ca333ba0b6b18acb7572285e92c26.png
--------------------------------------------------------------------------------
/media/4ca52ffeebc49306e76c74ed9062257d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4ca52ffeebc49306e76c74ed9062257d.png
--------------------------------------------------------------------------------
/media/4cc389ee95fbae485f1e014aad393aa8.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4cc389ee95fbae485f1e014aad393aa8.gif
--------------------------------------------------------------------------------
/media/4daa989affba4bd90fadec0d4236343a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4daa989affba4bd90fadec0d4236343a.png
--------------------------------------------------------------------------------
/media/4e3a6edca9e2bdafe7dd69fbdf76c8db.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4e3a6edca9e2bdafe7dd69fbdf76c8db.png
--------------------------------------------------------------------------------
/media/4f0ea97ad117848a71148849705e311e.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4f0ea97ad117848a71148849705e311e.png
--------------------------------------------------------------------------------
/media/4f558a475444869186a0641f934db534.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/4f558a475444869186a0641f934db534.gif
--------------------------------------------------------------------------------
/media/5136495bbdfbe2cefac98d74bd36a88f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5136495bbdfbe2cefac98d74bd36a88f.png
--------------------------------------------------------------------------------
/media/5502725fcc5648f2f6d18aaf68832505.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5502725fcc5648f2f6d18aaf68832505.gif
--------------------------------------------------------------------------------
/media/55787cfe149ebf1c574aa1da4eea678c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/55787cfe149ebf1c574aa1da4eea678c.png
--------------------------------------------------------------------------------
/media/56b6bb93cdc7ee8a05a1c6924f8d95c6.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/56b6bb93cdc7ee8a05a1c6924f8d95c6.png
--------------------------------------------------------------------------------
/media/5ae071ad7e34c7d0d6bc00f94811382f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5ae071ad7e34c7d0d6bc00f94811382f.png
--------------------------------------------------------------------------------
/media/5bab13cb8c49573cfda4fcad2222fe57.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5bab13cb8c49573cfda4fcad2222fe57.png
--------------------------------------------------------------------------------
/media/5c6f81f69eac7f61744ba3bc035b29e7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5c6f81f69eac7f61744ba3bc035b29e7.png
--------------------------------------------------------------------------------
/media/5dc2c211205677ed7ae1528cd1911685.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/5dc2c211205677ed7ae1528cd1911685.png
--------------------------------------------------------------------------------
/media/612e4a7da5eea52195e8994a9b22413c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/612e4a7da5eea52195e8994a9b22413c.png
--------------------------------------------------------------------------------
/media/63cf3b8bd556c6b1ce5a0436883c8f7b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/63cf3b8bd556c6b1ce5a0436883c8f7b.png
--------------------------------------------------------------------------------
/media/6439fb2f520bc6d99229517ca9bdbe6e.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6439fb2f520bc6d99229517ca9bdbe6e.png
--------------------------------------------------------------------------------
/media/6670e70b6d5f0f5152f643c153d13487.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6670e70b6d5f0f5152f643c153d13487.png
--------------------------------------------------------------------------------
/media/66a031ab14d56289d0987c65c73323af.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/66a031ab14d56289d0987c65c73323af.png
--------------------------------------------------------------------------------
/media/67cd5a65477ae19ad1e9ec5d821e474c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/67cd5a65477ae19ad1e9ec5d821e474c.png
--------------------------------------------------------------------------------
/media/685ea4b1fb85f093764bbaa58e13347d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/685ea4b1fb85f093764bbaa58e13347d.png
--------------------------------------------------------------------------------
/media/68eb47a320bce3bb717a2b690da4573d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/68eb47a320bce3bb717a2b690da4573d.png
--------------------------------------------------------------------------------
/media/6a6091b51c602923e5fe8b33e4422882.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6a6091b51c602923e5fe8b33e4422882.png
--------------------------------------------------------------------------------
/media/6ac0aaccb67a8a3975345dd133a30e0d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6ac0aaccb67a8a3975345dd133a30e0d.png
--------------------------------------------------------------------------------
/media/6b03a6feb6dee8e562c0970cb5417d6b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6b03a6feb6dee8e562c0970cb5417d6b.png
--------------------------------------------------------------------------------
/media/6ce64b147aa9f2c6635b18c08715437d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6ce64b147aa9f2c6635b18c08715437d.png
--------------------------------------------------------------------------------
/media/6d6657768e47e86b6522f6dd41a56ac2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/6d6657768e47e86b6522f6dd41a56ac2.png
--------------------------------------------------------------------------------
/media/7011ddacba948b383c12628c4f81c37f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/7011ddacba948b383c12628c4f81c37f.png
--------------------------------------------------------------------------------
/media/71732b73a7cb4fe508f504fca85b0db3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/71732b73a7cb4fe508f504fca85b0db3.png
--------------------------------------------------------------------------------
/media/72624869e303c62430942b0c55c4897a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/72624869e303c62430942b0c55c4897a.png
--------------------------------------------------------------------------------
/media/739df2baa4dbff3a74a4cdc6d1d651e7.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/739df2baa4dbff3a74a4cdc6d1d651e7.png
--------------------------------------------------------------------------------
/media/73a26c9835141996aa0470f756f95344.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/73a26c9835141996aa0470f756f95344.png
--------------------------------------------------------------------------------
/media/73dfb3c0a76ecd9d6faa62c025ace5e4.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/73dfb3c0a76ecd9d6faa62c025ace5e4.gif
--------------------------------------------------------------------------------
/media/74a2f4f519d0991c114aabf3318369b2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/74a2f4f519d0991c114aabf3318369b2.png
--------------------------------------------------------------------------------
/media/7759809055f85565e4bafedef312acc0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/7759809055f85565e4bafedef312acc0.png
--------------------------------------------------------------------------------
/media/77a84346325aa692f5e8b92741c6efb9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/77a84346325aa692f5e8b92741c6efb9.png
--------------------------------------------------------------------------------
/media/77d0c0bdc5ce8574c6ad319864abb032.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/77d0c0bdc5ce8574c6ad319864abb032.gif
--------------------------------------------------------------------------------
/media/792556dcff5f267dcc5aefeb5ef0d035.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/792556dcff5f267dcc5aefeb5ef0d035.png
--------------------------------------------------------------------------------
/media/7979628d61c6921f54b584d93f88a0bf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/7979628d61c6921f54b584d93f88a0bf.png
--------------------------------------------------------------------------------
/media/8276dc5ea73285406fa620d891bbc23a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/8276dc5ea73285406fa620d891bbc23a.png
--------------------------------------------------------------------------------
/media/853d21533f748c1c56a4151869a82a27.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/853d21533f748c1c56a4151869a82a27.gif
--------------------------------------------------------------------------------
/media/8f9080ee71094d948ab7592b449954bb.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/8f9080ee71094d948ab7592b449954bb.png
--------------------------------------------------------------------------------
/media/8fdf25878c4aff269ad26bc3002e7205.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/8fdf25878c4aff269ad26bc3002e7205.png
--------------------------------------------------------------------------------
/media/90962de7267c4d56e20456f01796ac29.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/90962de7267c4d56e20456f01796ac29.png
--------------------------------------------------------------------------------
/media/90cde9e64d700b21ced54c3610d9a88c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/90cde9e64d700b21ced54c3610d9a88c.png
--------------------------------------------------------------------------------
/media/91bc13de07d658b009ae498b5afa4ac1.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/91bc13de07d658b009ae498b5afa4ac1.gif
--------------------------------------------------------------------------------
/media/974f0f1b091afaba18ea375a73d87441.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/974f0f1b091afaba18ea375a73d87441.gif
--------------------------------------------------------------------------------
/media/9a737b0274b3fad6b6d2570bba64996a.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/9a737b0274b3fad6b6d2570bba64996a.gif
--------------------------------------------------------------------------------
/media/9aa41ee1e12bb8a72dd240dc42b44ba5.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/9aa41ee1e12bb8a72dd240dc42b44ba5.gif
--------------------------------------------------------------------------------
/media/9b468bff3f312fa70821da3a0a117f70.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/9b468bff3f312fa70821da3a0a117f70.png
--------------------------------------------------------------------------------
/media/9cb7a536001ffe21d63ecc68e368b4a0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/9cb7a536001ffe21d63ecc68e368b4a0.png
--------------------------------------------------------------------------------
/media/9d907772570668253e631c9235ac2623.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/9d907772570668253e631c9235ac2623.png
--------------------------------------------------------------------------------
/media/a3767cf99551c83f2db7f46d52b340d3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/a3767cf99551c83f2db7f46d52b340d3.png
--------------------------------------------------------------------------------
/media/a4bdf21cfdcad9b691198fa2486eaeb8.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/a4bdf21cfdcad9b691198fa2486eaeb8.png
--------------------------------------------------------------------------------
/media/a54faa33502b8c17066b1e2af09bdbb0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/a54faa33502b8c17066b1e2af09bdbb0.png
--------------------------------------------------------------------------------
/media/a86c70fc9172e988971f8a4a6fdc5bd0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/a86c70fc9172e988971f8a4a6fdc5bd0.png
--------------------------------------------------------------------------------
/media/ab7e53a364737d98ee06c53aef3108b0.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/ab7e53a364737d98ee06c53aef3108b0.png
--------------------------------------------------------------------------------
/media/af8ae3176c5521d1cf12466ec3e2b54d.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/af8ae3176c5521d1cf12466ec3e2b54d.png
--------------------------------------------------------------------------------
/media/b2810b869602f1a37d43ed871c038020.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b2810b869602f1a37d43ed871c038020.png
--------------------------------------------------------------------------------
/media/b4acd55e80fa396e2883b6968d5189e1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b4acd55e80fa396e2883b6968d5189e1.png
--------------------------------------------------------------------------------
/media/b58fa402bb2b4e16e53b0bda44a0e30e.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b58fa402bb2b4e16e53b0bda44a0e30e.png
--------------------------------------------------------------------------------
/media/b5a20f07b4812ea9f34ffb8e8783b73a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b5a20f07b4812ea9f34ffb8e8783b73a.png
--------------------------------------------------------------------------------
/media/b89dd5988d7d7ead6923dbc2d20e146c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b89dd5988d7d7ead6923dbc2d20e146c.png
--------------------------------------------------------------------------------
/media/b9bd3a0655d66dfdb5690e999db6ac32.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/b9bd3a0655d66dfdb5690e999db6ac32.png
--------------------------------------------------------------------------------
/media/bb111919295b7678530a1adcfa8b7d29.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/bb111919295b7678530a1adcfa8b7d29.png
--------------------------------------------------------------------------------
/media/c3ab348e58c5eb81b71284b3807943e4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/c3ab348e58c5eb81b71284b3807943e4.png
--------------------------------------------------------------------------------
/media/c59aebec0401c408755e8d427d973899.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/c59aebec0401c408755e8d427d973899.png
--------------------------------------------------------------------------------
/media/c649a1a7c43cffd86e55f28aeb8ff607.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/c649a1a7c43cffd86e55f28aeb8ff607.png
--------------------------------------------------------------------------------
/media/c7ef66e1ace9b544ba85d64f3f4ed1c4.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/c7ef66e1ace9b544ba85d64f3f4ed1c4.gif
--------------------------------------------------------------------------------
/media/cb771856f5b0a021a92acc162c9c13bd.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/cb771856f5b0a021a92acc162c9c13bd.png
--------------------------------------------------------------------------------
/media/cba8723ae722e8d2d13b94e0cf1fda7a.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/cba8723ae722e8d2d13b94e0cf1fda7a.png
--------------------------------------------------------------------------------
/media/ccb771014f600402fee72ca7134aea10.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/ccb771014f600402fee72ca7134aea10.gif
--------------------------------------------------------------------------------
/media/cd74a05babfcb9f75a746c9e98f2789b.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/cd74a05babfcb9f75a746c9e98f2789b.png
--------------------------------------------------------------------------------
/media/ce55033da131c4260c130ad3cb118bd5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/ce55033da131c4260c130ad3cb118bd5.png
--------------------------------------------------------------------------------
/media/ce8a6d4b9cd6df4c48cf914fae8a70d2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/ce8a6d4b9cd6df4c48cf914fae8a70d2.png
--------------------------------------------------------------------------------
/media/cfed8162c929bdf84a569ef649575563.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/cfed8162c929bdf84a569ef649575563.png
--------------------------------------------------------------------------------
/media/d00bee2b821eb3d268b99fb6ea94f916.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/d00bee2b821eb3d268b99fb6ea94f916.png
--------------------------------------------------------------------------------
/media/d06602b60d3af269409eb5633f8387c5.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/d06602b60d3af269409eb5633f8387c5.png
--------------------------------------------------------------------------------
/media/d4747b5b04d0887c1a49b974d187dc6f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/d4747b5b04d0887c1a49b974d187dc6f.png
--------------------------------------------------------------------------------
/media/d5e1fe52debddd4c5b288e3b6e9c5262.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/d5e1fe52debddd4c5b288e3b6e9c5262.png
--------------------------------------------------------------------------------
/media/da7d6c8c12d18b915018939970d2b911.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/da7d6c8c12d18b915018939970d2b911.png
--------------------------------------------------------------------------------
/media/da82a95da8f5e01d5de56f221c22d65c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/da82a95da8f5e01d5de56f221c22d65c.png
--------------------------------------------------------------------------------
/media/dccad19c5a07ffcd2477a9030d9337e7.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/dccad19c5a07ffcd2477a9030d9337e7.gif
--------------------------------------------------------------------------------
/media/e2554f0ea244f337c0e66ea34bf53edf.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/e2554f0ea244f337c0e66ea34bf53edf.gif
--------------------------------------------------------------------------------
/media/f01e9f4fd7eafca9b8a6eceeb6aec383.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f01e9f4fd7eafca9b8a6eceeb6aec383.png
--------------------------------------------------------------------------------
/media/f06f930419cee402a7a5cac1de4b1557.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f06f930419cee402a7a5cac1de4b1557.png
--------------------------------------------------------------------------------
/media/f0839a5643114a83f16d647c8c8299d3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f0839a5643114a83f16d647c8c8299d3.png
--------------------------------------------------------------------------------
/media/f25b3e3bc94bed108b0c454413f79873.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f25b3e3bc94bed108b0c454413f79873.png
--------------------------------------------------------------------------------
/media/f3b8490d4e41a8da5e954aabf0a4aacf.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f3b8490d4e41a8da5e954aabf0a4aacf.png
--------------------------------------------------------------------------------
/media/f558d2899635882ec517e2b1da5a0a8f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f558d2899635882ec517e2b1da5a0a8f.png
--------------------------------------------------------------------------------
/media/f621d8dd39147a621753b36d643cf42f.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f621d8dd39147a621753b36d643cf42f.png
--------------------------------------------------------------------------------
/media/f67a3249ad8b040417f195c3ca11f795.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/f67a3249ad8b040417f195c3ca11f795.png
--------------------------------------------------------------------------------
/media/fcbcd21ab48a370aa550ce594ade1794.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/fcbcd21ab48a370aa550ce594ade1794.png
--------------------------------------------------------------------------------
/media/fd0d20c24fda6e6b4d654a468ed84d2c.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/fd0d20c24fda6e6b4d654a468ed84d2c.png
--------------------------------------------------------------------------------
/media/fd2c7004f31d57eb9822307aac8afef9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/fd2c7004f31d57eb9822307aac8afef9.png
--------------------------------------------------------------------------------
/media/ff831787f6acc1e38a7f70dc47925ee0.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/ff831787f6acc1e38a7f70dc47925ee0.gif
--------------------------------------------------------------------------------
/media/image-20240829080057376.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829080057376.png
--------------------------------------------------------------------------------
/media/image-20240829080659528.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829080659528.png
--------------------------------------------------------------------------------
/media/image-20240829081015123.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081015123.png
--------------------------------------------------------------------------------
/media/image-20240829081049988.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081049988.png
--------------------------------------------------------------------------------
/media/image-20240829081346732.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081346732.png
--------------------------------------------------------------------------------
/media/image-20240829081541149.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081541149.png
--------------------------------------------------------------------------------
/media/image-20240829081620633.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081620633.png
--------------------------------------------------------------------------------
/media/image-20240829081719592.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081719592.png
--------------------------------------------------------------------------------
/media/image-20240829081916316.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081916316.png
--------------------------------------------------------------------------------
/media/image-20240829081950365.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829081950365.png
--------------------------------------------------------------------------------
/media/image-20240829082024079.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082024079.png
--------------------------------------------------------------------------------
/media/image-20240829082055680.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082055680.png
--------------------------------------------------------------------------------
/media/image-20240829082201268.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082201268.png
--------------------------------------------------------------------------------
/media/image-20240829082231096.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082231096.png
--------------------------------------------------------------------------------
/media/image-20240829082255780.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082255780.png
--------------------------------------------------------------------------------
/media/image-20240829082344150.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082344150.png
--------------------------------------------------------------------------------
/media/image-20240829082406694.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082406694.png
--------------------------------------------------------------------------------
/media/image-20240829082635337.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082635337.png
--------------------------------------------------------------------------------
/media/image-20240829082659498.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082659498.png
--------------------------------------------------------------------------------
/media/image-20240829082837729.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082837729.png
--------------------------------------------------------------------------------
/media/image-20240829082946033.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829082946033.png
--------------------------------------------------------------------------------
/media/image-20240829083025561.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083025561.png
--------------------------------------------------------------------------------
/media/image-20240829083106816.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083106816.png
--------------------------------------------------------------------------------
/media/image-20240829083417393.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083417393.png
--------------------------------------------------------------------------------
/media/image-20240829083549751.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083549751.png
--------------------------------------------------------------------------------
/media/image-20240829083610439.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083610439.png
--------------------------------------------------------------------------------
/media/image-20240829083656994.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083656994.png
--------------------------------------------------------------------------------
/media/image-20240829083740371.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083740371.png
--------------------------------------------------------------------------------
/media/image-20240829083807720.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083807720.png
--------------------------------------------------------------------------------
/media/image-20240829083858029.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083858029.png
--------------------------------------------------------------------------------
/media/image-20240829083941927.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829083941927.png
--------------------------------------------------------------------------------
/media/image-20240829084258188.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084258188.png
--------------------------------------------------------------------------------
/media/image-20240829084319943.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084319943.png
--------------------------------------------------------------------------------
/media/image-20240829084347280.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084347280.png
--------------------------------------------------------------------------------
/media/image-20240829084425105.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084425105.png
--------------------------------------------------------------------------------
/media/image-20240829084512423.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084512423.png
--------------------------------------------------------------------------------
/media/image-20240829084537503.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084537503.png
--------------------------------------------------------------------------------
/media/image-20240829084610339.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084610339.png
--------------------------------------------------------------------------------
/media/image-20240829084636349.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084636349.png
--------------------------------------------------------------------------------
/media/image-20240829084700560.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084700560.png
--------------------------------------------------------------------------------
/media/image-20240829084730629.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084730629.png
--------------------------------------------------------------------------------
/media/image-20240829084841772.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084841772.png
--------------------------------------------------------------------------------
/media/image-20240829084901737.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829084901737.png
--------------------------------------------------------------------------------
/media/image-20240829085005983.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085005983.png
--------------------------------------------------------------------------------
/media/image-20240829085045336.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085045336.png
--------------------------------------------------------------------------------
/media/image-20240829085119472.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085119472.png
--------------------------------------------------------------------------------
/media/image-20240829085146797.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085146797.png
--------------------------------------------------------------------------------
/media/image-20240829085209463.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085209463.png
--------------------------------------------------------------------------------
/media/image-20240829085254141.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085254141.png
--------------------------------------------------------------------------------
/media/image-20240829085727776.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085727776.png
--------------------------------------------------------------------------------
/media/image-20240829085852775.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085852775.png
--------------------------------------------------------------------------------
/media/image-20240829085935810.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829085935810.png
--------------------------------------------------------------------------------
/media/image-20240829090305653.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090305653.png
--------------------------------------------------------------------------------
/media/image-20240829090434767.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090434767.png
--------------------------------------------------------------------------------
/media/image-20240829090550499.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090550499.png
--------------------------------------------------------------------------------
/media/image-20240829090612617.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090612617.png
--------------------------------------------------------------------------------
/media/image-20240829090632045.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090632045.png
--------------------------------------------------------------------------------
/media/image-20240829090658864.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829090658864.png
--------------------------------------------------------------------------------
/media/image-20240829091316193.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829091316193.png
--------------------------------------------------------------------------------
/media/image-20240829091450756.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829091450756.png
--------------------------------------------------------------------------------
/media/image-20240829091539440.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829091539440.png
--------------------------------------------------------------------------------
/media/image-20240829091801038.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829091801038.png
--------------------------------------------------------------------------------
/media/image-20240829092027870.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092027870.png
--------------------------------------------------------------------------------
/media/image-20240829092050429.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092050429.png
--------------------------------------------------------------------------------
/media/image-20240829092158912.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092158912.png
--------------------------------------------------------------------------------
/media/image-20240829092329794.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092329794.png
--------------------------------------------------------------------------------
/media/image-20240829092612681.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092612681.png
--------------------------------------------------------------------------------
/media/image-20240829092656320.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092656320.png
--------------------------------------------------------------------------------
/media/image-20240829092940314.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092940314.png
--------------------------------------------------------------------------------
/media/image-20240829092959775.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829092959775.png
--------------------------------------------------------------------------------
/media/image-20240829093518737.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829093518737.png
--------------------------------------------------------------------------------
/media/image-20240829093552414.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829093552414.png
--------------------------------------------------------------------------------
/media/image-20240829093934212.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829093934212.png
--------------------------------------------------------------------------------
/media/image-20240829094221268.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829094221268.png
--------------------------------------------------------------------------------
/media/image-20240829095452552.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829095452552.png
--------------------------------------------------------------------------------
/media/image-20240829100209917.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829100209917.png
--------------------------------------------------------------------------------
/media/image-20240829100245272.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829100245272.png
--------------------------------------------------------------------------------
/media/image-20240829100432417.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829100432417.png
--------------------------------------------------------------------------------
/media/image-20240829100937477.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829100937477.png
--------------------------------------------------------------------------------
/media/image-20240829101111288.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101111288.png
--------------------------------------------------------------------------------
/media/image-20240829101222447.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101222447.png
--------------------------------------------------------------------------------
/media/image-20240829101254601.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101254601.png
--------------------------------------------------------------------------------
/media/image-20240829101332034.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101332034.png
--------------------------------------------------------------------------------
/media/image-20240829101534550.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101534550.png
--------------------------------------------------------------------------------
/media/image-20240829101612063.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101612063.png
--------------------------------------------------------------------------------
/media/image-20240829101632142.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101632142.png
--------------------------------------------------------------------------------
/media/image-20240829101650730.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101650730.png
--------------------------------------------------------------------------------
/media/image-20240829101712694.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101712694.png
--------------------------------------------------------------------------------
/media/image-20240829101915930.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101915930.png
--------------------------------------------------------------------------------
/media/image-20240829101936734.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101936734.png
--------------------------------------------------------------------------------
/media/image-20240829101956608.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829101956608.png
--------------------------------------------------------------------------------
/media/image-20240829102020166.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829102020166.png
--------------------------------------------------------------------------------
/media/image-20240829102323261.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829102323261.png
--------------------------------------------------------------------------------
/media/image-20240829102344815.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829102344815.png
--------------------------------------------------------------------------------
/media/image-20240829102642856.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829102642856.png
--------------------------------------------------------------------------------
/media/image-20240829102703396.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829102703396.png
--------------------------------------------------------------------------------
/media/image-20240829103131857.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829103131857.png
--------------------------------------------------------------------------------
/media/image-20240829103236734.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829103236734.png
--------------------------------------------------------------------------------
/media/image-20240829103259992.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829103259992.png
--------------------------------------------------------------------------------
/media/image-20240829104222478.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104222478.png
--------------------------------------------------------------------------------
/media/image-20240829104512068.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104512068.png
--------------------------------------------------------------------------------
/media/image-20240829104533718.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104533718.png
--------------------------------------------------------------------------------
/media/image-20240829104554155.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104554155.png
--------------------------------------------------------------------------------
/media/image-20240829104639402.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104639402.png
--------------------------------------------------------------------------------
/media/image-20240829104851205.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104851205.png
--------------------------------------------------------------------------------
/media/image-20240829104924497.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104924497.png
--------------------------------------------------------------------------------
/media/image-20240829104945257.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829104945257.png
--------------------------------------------------------------------------------
/media/image-20240829105004347.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105004347.png
--------------------------------------------------------------------------------
/media/image-20240829105130499.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105130499.png
--------------------------------------------------------------------------------
/media/image-20240829105242300.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105242300.png
--------------------------------------------------------------------------------
/media/image-20240829105258689.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105258689.png
--------------------------------------------------------------------------------
/media/image-20240829105418671.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105418671.png
--------------------------------------------------------------------------------
/media/image-20240829105441723.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105441723.png
--------------------------------------------------------------------------------
/media/image-20240829105506722.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105506722.png
--------------------------------------------------------------------------------
/media/image-20240829105659262.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829105659262.png
--------------------------------------------------------------------------------
/media/image-20240829110009589.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110009589.png
--------------------------------------------------------------------------------
/media/image-20240829110334937.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110334937.png
--------------------------------------------------------------------------------
/media/image-20240829110513812.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110513812.png
--------------------------------------------------------------------------------
/media/image-20240829110533157.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110533157.png
--------------------------------------------------------------------------------
/media/image-20240829110551420.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110551420.png
--------------------------------------------------------------------------------
/media/image-20240829110903709.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110903709.png
--------------------------------------------------------------------------------
/media/image-20240829110922449.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110922449.png
--------------------------------------------------------------------------------
/media/image-20240829110943245.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829110943245.png
--------------------------------------------------------------------------------
/media/image-20240829111514798.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111514798.png
--------------------------------------------------------------------------------
/media/image-20240829111542163.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111542163.png
--------------------------------------------------------------------------------
/media/image-20240829111619905.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111619905.png
--------------------------------------------------------------------------------
/media/image-20240829111645952.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111645952.png
--------------------------------------------------------------------------------
/media/image-20240829111711642.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111711642.png
--------------------------------------------------------------------------------
/media/image-20240829111732678.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111732678.png
--------------------------------------------------------------------------------
/media/image-20240829111753566.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111753566.png
--------------------------------------------------------------------------------
/media/image-20240829111911455.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111911455.png
--------------------------------------------------------------------------------
/media/image-20240829111935904.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111935904.png
--------------------------------------------------------------------------------
/media/image-20240829111959287.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829111959287.png
--------------------------------------------------------------------------------
/media/image-20240829112229366.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829112229366.png
--------------------------------------------------------------------------------
/media/image-20240829112250200.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829112250200.png
--------------------------------------------------------------------------------
/media/image-20240829112326190.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829112326190.png
--------------------------------------------------------------------------------
/media/image-20240829112700824.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829112700824.png
--------------------------------------------------------------------------------
/media/image-20240829112906641.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829112906641.png
--------------------------------------------------------------------------------
/media/image-20240829113049624.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113049624.png
--------------------------------------------------------------------------------
/media/image-20240829113113252.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113113252.png
--------------------------------------------------------------------------------
/media/image-20240829113134905.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113134905.png
--------------------------------------------------------------------------------
/media/image-20240829113628989.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113628989.png
--------------------------------------------------------------------------------
/media/image-20240829113649785.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113649785.png
--------------------------------------------------------------------------------
/media/image-20240829113734608.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113734608.png
--------------------------------------------------------------------------------
/media/image-20240829113824280.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113824280.png
--------------------------------------------------------------------------------
/media/image-20240829113916829.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113916829.png
--------------------------------------------------------------------------------
/media/image-20240829113948830.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829113948830.png
--------------------------------------------------------------------------------
/media/image-20240829114017540.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114017540.png
--------------------------------------------------------------------------------
/media/image-20240829114037360.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114037360.png
--------------------------------------------------------------------------------
/media/image-20240829114100020.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114100020.png
--------------------------------------------------------------------------------
/media/image-20240829114526325.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114526325.png
--------------------------------------------------------------------------------
/media/image-20240829114557565.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114557565.png
--------------------------------------------------------------------------------
/media/image-20240829114945572.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829114945572.png
--------------------------------------------------------------------------------
/media/image-20240829115033197.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115033197.png
--------------------------------------------------------------------------------
/media/image-20240829115125819.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115125819.png
--------------------------------------------------------------------------------
/media/image-20240829115210707.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115210707.png
--------------------------------------------------------------------------------
/media/image-20240829115241352.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115241352.png
--------------------------------------------------------------------------------
/media/image-20240829115301443.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115301443.png
--------------------------------------------------------------------------------
/media/image-20240829115320081.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115320081.png
--------------------------------------------------------------------------------
/media/image-20240829115410814.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115410814.png
--------------------------------------------------------------------------------
/media/image-20240829115454755.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115454755.png
--------------------------------------------------------------------------------
/media/image-20240829115606145.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115606145.png
--------------------------------------------------------------------------------
/media/image-20240829115642934.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115642934.png
--------------------------------------------------------------------------------
/media/image-20240829115703081.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115703081.png
--------------------------------------------------------------------------------
/media/image-20240829115724267.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829115724267.png
--------------------------------------------------------------------------------
/media/image-20240829151638122.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829151638122.png
--------------------------------------------------------------------------------
/media/image-20240829151823981.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829151823981.png
--------------------------------------------------------------------------------
/media/image-20240829204745429.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240829204745429.png
--------------------------------------------------------------------------------
/media/image-20240830114557281.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240830114557281.png
--------------------------------------------------------------------------------
/media/image-20240830214738439.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240830214738439.png
--------------------------------------------------------------------------------
/media/image-20240901095750255.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240901095750255.png
--------------------------------------------------------------------------------
/media/image-20240901103231333.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240901103231333.png
--------------------------------------------------------------------------------
/media/image-20240901104239714.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240901104239714.png
--------------------------------------------------------------------------------
/media/image-20240902000000001.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240902000000001.png
--------------------------------------------------------------------------------
/media/image-20240902000000002.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240902000000002.png
--------------------------------------------------------------------------------
/media/image-20240902000000003.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-20240902000000003.png
--------------------------------------------------------------------------------
/media/image-bulk-insert-degrade.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-bulk-insert-degrade.png
--------------------------------------------------------------------------------
/media/image-bulk-insert-optimize.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-bulk-insert-optimize.png
--------------------------------------------------------------------------------
/media/image-degrade.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-degrade.png
--------------------------------------------------------------------------------
/media/image-degrade2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-degrade2.png
--------------------------------------------------------------------------------
/media/image-degrade3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-degrade3.png
--------------------------------------------------------------------------------
/media/image-degrade4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-degrade4.png
--------------------------------------------------------------------------------
/media/image-join-degrade.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-join-degrade.png
--------------------------------------------------------------------------------
/media/image-join-improve.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-join-improve.png
--------------------------------------------------------------------------------
/media/image-thread-pool.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/enhancedformysql/The-Art-of-Problem-Solving-in-Software-Engineering_How-to-Make-MySQL-Better/d6078d3be007ede85bcfb7052f2b7e5c8e75ad11/media/image-thread-pool.png
--------------------------------------------------------------------------------