Die neue Hitzewelle von MySQL verstehen

Datenanalyse ist in jedem Unternehmen wichtig, da Sie sehen können, was in der Vergangenheit passiert ist, um intelligente Entscheidungen treffen oder sogar zukünftige Aktionen anhand der vorhandenen Daten vorhersagen zu können.

Das Analysieren einer riesigen Datenmenge kann schwierig sein, und Sie sollten mehr als eine Datenbank-Engine verwenden müssen, um OLTP- und OLAP-Workloads zu bewältigen. In diesem Blog werden wir sehen, was HeatWave ist und wie es Ihnen bei dieser Aufgabe helfen kann.

Was ist HeatWave?

HeatWave ist eine neue integrierte Engine für den MySQL-Datenbankdienst in der Cloud. Es handelt sich um eine verteilte, skalierbare, Shared-Nothing-, In-Memory-, spaltenbasierte Abfrageverarbeitungs-Engine, die für die schnelle Ausführung analytischer Abfragen entwickelt wurde. Laut der offiziellen Dokumentation beschleunigt es die MySQL-Leistung bei Analyseabfragen um das 400-fache, skaliert auf Tausende von Kernen und ist 2,7-mal schneller bei etwa einem Drittel der Kosten der direkten Konkurrenten. Der MySQL-Datenbankdienst mit HeatWave ist der einzige Dienst zum Ausführen von OLTP- und OLAP-Workloads direkt aus der MySQL-Datenbank.

Wie HeatWave funktioniert

Ein HeatWave-Cluster enthält einen MySQL-DB-Systemknoten und zwei oder mehr HeatWave-Knoten. Der MySQL-DB-Systemknoten verfügt über ein HeatWave-Plugin, das für die Clusterverwaltung, das Laden von Daten in den HeatWave-Cluster, die Abfrageplanung und die Rückgabe von Abfrageergebnissen an das MySQL-DB-System verantwortlich ist. HeatWave-Knoten speichern Daten im Arbeitsspeicher und verarbeiten Analyseabfragen. Jeder HeatWave-Knoten enthält eine Instanz von HeatWave.

Die Anzahl der erforderlichen HeatWave-Knoten hängt von der Größe Ihrer Daten und der Komprimierung ab, die beim Laden der Daten in den HeatWave-Cluster erreicht wird. Wir können die Architektur dieses Produkts im folgenden Bild sehen:

Wie Sie sehen können, greifen Benutzer nicht direkt auf den HeatWave-Cluster zu. Abfragen, die bestimmte Voraussetzungen erfüllen, werden zur beschleunigten Verarbeitung automatisch vom MySQL-DB-System an den HeatWave-Cluster ausgelagert, und die Ergebnisse werden an den MySQL-DB-Systemknoten und dann an den MySQL-Client oder die MySQL-Anwendung zurückgegeben, die die Abfrage ausgegeben hat.

Wie man es benutzt

Um diese Funktion zu aktivieren, müssen Sie auf die Oracle Cloud Management Site zugreifen, auf das vorhandene MySQL-DB-System zugreifen (oder ein neues erstellen) und einen Analitycs-Cluster hinzufügen. Dort können Sie den Typ des Clusters und die Anzahl der Knoten angeben. Sie können die Funktion "Knotenanzahl schätzen" verwenden, um die erforderliche Anzahl basierend auf Ihrer Arbeitslast zu ermitteln.

Das Laden von Daten in einen HeatWave-Cluster erfordert das Vorbereiten von Tabellen auf dem MySQL-DB-System und das Ausführen von Tabellenladevorgängen.

Tabellen vorbereiten

Das Vorbereiten von Tabellen umfasst das Ändern von Tabellendefinitionen, um bestimmte Spalten auszuschließen, Zeichenfolgen-Spaltencodierungen zu definieren, Datenplatzierungsschlüssel hinzuzufügen und HeatWave (RAPID) als sekundäre Engine für die Tabelle anzugeben, da InnoDB die primäre ist.

Um RAPID als sekundäre Engine für eine Tabelle zu definieren, geben Sie die Tabellenoption SECONDARY_ENGINE in einer CREATE TABLE- oder ALTER TABLE-Anweisung an:

mysql> CREATE TABLE orders (id INT) SECONDARY_ENGINE = RAPID;
or
mysql> ALTER TABLE orders SECONDARY_ENGINE = RAPID;

Daten werden geladen

Das Laden einer Tabelle in einen HeatWave-Cluster erfordert die Ausführung einer ALTER TABLE-Operation mit dem Schlüsselwort SECONDARY_LOAD.

mysql> ALTER TABLE orders SECONDARY_LOAD;

Wenn eine Tabelle geladen wird, werden die Daten horizontal aufgeteilt und auf HeatWave-Knoten verteilt. Nachdem eine Tabelle geladen wurde, werden Änderungen an den Daten einer Tabelle auf dem MySQL-DB-Systemknoten automatisch an die HeatWave-Knoten weitergegeben.

Beispiel

Für dieses Beispiel verwenden wir die Tabellenreihenfolge:

mysql> SHOW CREATE TABLE orders\G
*************************** 1. row ***************************
       Table: orders
Create Table: CREATE TABLE `orders` (
  `O_ORDERKEY` int NOT NULL,
  `O_CUSTKEY` int NOT NULL,
  `O_ORDERSTATUS` char(1) COLLATE utf8mb4_bin NOT NULL,
  `O_TOTALPRICE` decimal(15,2) NOT NULL,
  `O_ORDERDATE` date NOT NULL,
  `O_ORDERPRIORITY` char(15) COLLATE utf8mb4_bin NOT NULL,
  `O_CLERK` char(15) COLLATE utf8mb4_bin NOT NULL,
  `O_SHIPPRIORITY` int NOT NULL,
  `O_COMMENT` varchar(79) COLLATE utf8mb4_bin NOT NULL,
  PRIMARY KEY (`O_ORDERKEY`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin

Sie können Spalten ausschließen, die Sie nicht in HeatWave laden möchten:

mysql> ALTER TABLE orders MODIFY `O_COMMENT` varchar(79) NOT NULL NOT SECONDARY;

Definieren Sie jetzt RAPID als SECONDARY_ENGINE für die Tabelle:

mysql> ALTER TABLE orders SECONDARY_ENGINE RAPID;

Stellen Sie sicher, dass Sie den Parameter SECONDARY_ENGINE in der Tabellendefinition hinzugefügt haben:

ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin SECONDARY_ENGINE=RAPID

Und schließlich laden Sie die Tabelle in HeatWave:

mysql> ALTER TABLE orders SECONDARY_LOAD;

Sie können EXPLAIN verwenden, um zu überprüfen, ob es die richtige Engine verwendet. Sie sollten so etwas sehen:

Extra:Verwendung von where; Temporär verwenden; Filesort verwenden; Verwendung der sekundären Engine RAPID

Auf der offiziellen MySQL-Site können Sie einen Vergleich zwischen einer normalen Ausführung und der Verwendung von HeatWave sehen:

HeatWave-Ausführung

mysql> SELECT O_ORDERPRIORITY, COUNT(*) AS ORDER_COUNT FROM orders 
       WHERE O_ORDERDATE >= DATE '1994-03-01' GROUP BY O_ORDERPRIORITY 
       ORDER BY O_ORDERPRIORITY;
+-----------------+-------------+
| O_ORDERPRIORITY | ORDER_COUNT |
+-----------------+-------------+
| 1-URGENT        |     2017573 |
| 2-HIGH          |     2015859 |
| 3-MEDIUM        |     2013174 |
| 4-NOT SPECIFIED |     2014476 |
| 5-LOW           |     2013674 |
+-----------------+-------------+
5 rows in set (0.04 sec)

Normale Ausführung

mysql> SELECT O_ORDERPRIORITY, COUNT(*) AS ORDER_COUNT FROM orders 
       WHERE O_ORDERDATE >= DATE '1994-03-01' GROUP BY O_ORDERPRIORITY 
       ORDER BY O_ORDERPRIORITY;
+-----------------+-------------+
| O_ORDERPRIORITY | ORDER_COUNT |
+-----------------+-------------+
| 1-URGENT        |     2017573 |
| 2-HIGH          |     2015859 |
| 3-MEDIUM        |     2013174 |
| 4-NOT SPECIFIED |     2014476 |
| 5-LOW           |     2013674 |
+-----------------+-------------+
5 rows in set (8.91 sec)

Wie Sie sehen können, gibt es selbst bei einer einfachen Abfrage einen wichtigen Unterschied im Zeitpunkt der Abfrage. Weitere Informationen finden Sie in der offiziellen Dokumentation.

Fazit

Eine einzige MySQL-Datenbank kann sowohl für OLTP- als auch für Analyseanwendungen verwendet werden. Es ist zu 100 % mit MySQL On-Premises kompatibel, sodass Sie Ihre OLTP-Workloads On-Premises behalten und Ihre Analytics-Workloads ohne Änderungen in Ihrer Anwendung auf HeatWave auslagern oder sogar direkt in der Oracle Cloud verwenden können, um Ihre MySQL-Performance für Analytics zu verbessern Zwecke.