Lernen Sie die Prinzipien und allgemeinen Operationen von MySQL-Partitionstabellen anhand von Beispielen kennen

Lernen Sie die Prinzipien und allgemeinen Operationen von MySQL-Partitionstabellen anhand von Beispielen kennen

1. Bedeutung der Partitionstabelle

Eine Partitionstabellendefinition teilt mehrere Teile einer einzelnen Tabelle über das Dateisystem zu. Dabei richtet sich die Größe nach Regeln, die auf eine beliebige Größe eingestellt werden können. Tatsächlich werden verschiedene Teile der Tabelle als separate Tabellen an verschiedenen Speicherorten gespeichert. Die vom Benutzer zur Datensegmentierung ausgewählte Regel wird als Partitionsfunktion bezeichnet und kann in MySQL ein Modul, eine einfache Übereinstimmung mit einem kontinuierlichen numerischen Bereich oder einer Liste numerischer Werte, eine interne HASH-Funktion oder eine lineare HASH-Funktion sein.

Der Unterschied zwischen Tabellen-Sharding und -Partitionierung besteht darin, dass sich in einer Partition logischerweise nur eine Tabelle befindet, während beim Tabellen-Sharding eine Tabelle in mehrere Tabellen zerlegt wird.

2. Vorteile der Partitionstabelle

1) Partitionstabellen sind einfacher zu verwalten. Bei Daten, deren Speicherung ihren Sinn verloren hat, ist es normalerweise einfach, sie zu löschen, indem man die mit den Daten verknüpften Partitionen löscht. Umgekehrt kann in einigen Fällen das Hinzufügen neuer Daten bequem durch das Hinzufügen einer neuen Partition speziell für diese neuen Daten implementiert werden.

2) Einige Abfragen können erheblich optimiert werden, hauptsächlich dadurch, dass die Tatsache ausgenutzt wird, dass die Daten, die eine bestimmte WHERE-Anweisung erfüllen, nur in einer oder mehreren Partitionen gespeichert werden können, sodass bei der Suche keine Notwendigkeit besteht, andere verbleibende Partitionen zu durchsuchen. Da Partitionen nach der Erstellung einer partitionierten Tabelle geändert werden können, können Sie Ihre Daten neu organisieren, um die Effizienz häufig verwendeter Abfragen zu verbessern, falls Sie dies bei der ersten Konfiguration des Partitionierungsschemas nicht getan haben.

3) Abfragen optimieren. Beispielsweise können SUM() und COUNT() parallel auf mehreren Partitionen verarbeitet werden und das Endergebnis ist einfach die Summe der Ergebnisse aller Partitionen.

4) Erzielen Sie einen höheren Abfragedurchsatz, indem Sie Datenabfragen auf mehrere Festplatten verteilen.

3. Einschränkungen der Partitionstabelle

1) Eine Tabelle kann maximal 1024 Partitionen haben;

2) In MySQL 5.1 muss der Partitionierungsausdruck eine Ganzzahl oder ein Ausdruck sein, der eine Ganzzahl zurückgibt. MySQL 5.5 bietet Unterstützung für die Partitionierung nicht-ganzzahliger Ausdrücke;

3) Wenn das Partitionsfeld Primärschlüssel- oder eindeutige Indexspalten enthält, müssen alle Primärschlüsselspalten und eindeutigen Indexspalten einbezogen werden. Das heißt, das Partitionsfeld enthält entweder nicht den Primärschlüssel oder die Indexspalte oder enthält alle Primärschlüssel- und Indexspalten.

4) Fremdschlüsseleinschränkungen können in Partitionstabellen nicht verwendet werden;

5) Die MySQL-Partitionierung gilt für alle Daten und Indizes einer Tabelle. Sie können nicht nur Tabellendaten partitionieren, ohne die Indizes zu partitionieren, nur Indizes partitionieren, ohne die Tabellen zu partitionieren, oder nur einen Teil der Tabellendaten partitionieren.

6) Der Partitionsschlüssel muss vom Typ INT sein oder ein Ausdruck, der den Typ INT zurückgibt und NULL sein kann. Die einzige Ausnahme besteht darin, dass Sie, wenn der Partitionstyp eine KEY-Partition ist, andere Spaltentypen als Partitionsschlüssel verwenden können (außer BLOB- oder TEXT-Spalten).

7) Wenn die Tabelle einen Primärschlüssel und einen eindeutigen Index hat, sollte bei der Partitionierung nach dem Primärschlüsselfeld die Spalte mit dem eindeutigen Index den Partitionsschlüssel enthalten.

8) Derzeit unterstützt MySQL keine Partitionierung von räumlichen Typen und temporären Tabellentypen. Volltextindizierung wird nicht unterstützt.

9) Objektbeschränkungen (Partitionsausdrücke dürfen keine gespeicherten Funktionen, gespeicherten Prozeduren, UDFs oder Plugins, deklarierte Variablen oder Benutzervariablen enthalten.)

10) Operationsbeschränkungen (Addition, Subtraktion, Multiplikation und andere Operationen werden in Partitionsausdrücken unterstützt, aber das Ergebnis der Operation muss ein INT oder NULL sein. DIV wird unterstützt, aber /, |, &, ^, <<, >> und ~ werden nicht unterstützt und dürfen nicht in Partitionsausdrücken erscheinen)

11) SQL_Mode-Einschränkungen (Wir empfehlen dringend, den SQL_Mode von MySQL nach dem Erstellen einer partitionierten Tabelle niemals zu ändern. Denn in verschiedenen Modi können die von einigen Funktionen oder Vorgängen zurückgegebenen Ergebnisse unterschiedlich sein.)

12) query_cache und INSERT DELAYED werden nicht unterstützt

13) Der Partitionsschlüssel kann keine Unterabfrage sein (auch wenn die Unterabfrage einen int-Wert oder null zurückgibt).

14) Unterpartitionierungsbeschränkungen (nur RANG- und LIST-Partitionen können unterteilt werden. HASH- und KEY-Partitionen können nicht unterteilt werden und die Unterpartitionen müssen vom Typ HASH oder KEY sein)

4. Partitionstyp

1) Horizontale Partitionierung (zeilenweise basierend auf Spaltenattributen)

Beispielsweise kann eine Tabelle mit Rechnungsdatensätzen aus zehn Jahren in zehn unterschiedliche Partitionen aufgeteilt werden, von denen jede Datensätze für ein Jahr enthält.

Mehrere Modi der horizontalen Partitionierung:

* Bereich: Dieser Modus ermöglicht dem DBA, Daten in verschiedene Bereiche aufzuteilen.

Beispielsweise kann eine Tabelle nach Jahr in drei Abschnitte unterteilt werden: Daten aus den 1980er Jahren, Daten aus den 1990er Jahren und alle Daten nach dem Jahr 2000 (einschließlich 2000).

* Hash: Dieser Modus ermöglicht es dem DBA, den Hash-Schlüssel einer oder mehrerer Spalten der Tabelle zu berechnen und schließlich den Datenbereich entsprechend den unterschiedlichen Werten des Hash-Codes zu partitionieren.

Sie können beispielsweise eine Tabelle erstellen, die den Primärschlüssel der Tabelle partitioniert.

* Schlüssel: Eine Erweiterung des obigen Hash-Modus. Der Hash-Schlüssel wird hier vom MySQL-System generiert.

* Liste (vordefinierte Liste): Dieser Modus ermöglicht dem System, die Zeilendaten entsprechend den Werten der vom DBA definierten Liste aufzuteilen. Beispiel: Der DBA erstellt eine Tabelle über drei Partitionen hinweg, basierend auf Daten, die den Werten von 2004, 2005 und 2006 entsprechen.

* Die Spaltenpartitionierung ist eine Ergänzung zur Bereichs- und Listenpartitionierung. Sie gleicht die Tatsache aus, dass die beiden letzteren nur die Ganzzahlpartitionierung unterstützen (oder durch Konvertierung in Ganzzahlen), sodass die unterstützten Datentypen erheblich erweitert werden (alle Ganzzahltypen, Datums- und Zeittypen, Zeichentypen) und auch die Partitionierung mehrerer Spalten unterstützt wird.

Hinweis: Beim Einfügen von Daten in eine mehrspaltige Partitionstabelle wird ein Tupelvergleich verwendet, d. h. es wird eine mehrspaltige Sortierung durchgeführt, wobei zuerst nach Feld1 sortiert wird, dann nach Feld2 sortiert wird und die Daten entsprechend den Sortierergebnissen partitioniert und gespeichert werden.

* Composite: Eine Kombination der oben genannten Modi.

Beispielsweise können Sie bei einer Tabelle, die ursprünglich bereichspartitioniert war, auf einer der Partitionen eine Hash-Partitionierung durchführen.

Vertikale Partitionierung (nach Spalten):

Wenn eine Tabelle beispielsweise große Text- und BLOB-Spalten enthält, auf die nicht häufig zugegriffen wird, können Sie diese selten verwendeten Text- und BLOB-Spalten in eine andere Partition partitionieren. Dadurch wird die Zugriffsgeschwindigkeit verbessert und gleichzeitig die Relevanz der Daten sichergestellt.

Hinweis: Unterpartition (Schlüsselwort Unterpartition): RANGE- oder LIST-Partitionierung kann weiter aufgeteilt werden, um Unterpartitionen zu bilden, die HASH-Partitionen oder KEY-Partitionen sein können. Empfohlen für die Verwendung auf mehreren Festplatten.

Überprüfen Sie, ob die Partitionstabelle unterstützt wird

mysql> PLUGINS ANZEIGEN;
 +----------------------------+----------+--------------------+---------+---------+
 | Name | Status | Typ | Bibliothek | Lizenz |
 +----------------------------+----------+--------------------+---------+---------+
 | Partition | AKTIV | SPEICHER-ENGINE | NULL | GPL |
 +----------------------------+----------+--------------------+---------+---------+
 Oder verwenden Sie mysql> SELECT PLUGIN_NAME als Name, PLUGIN_VERSION als Version, PLUGIN_STATUS als Status
 -> VON INFORMATION_SCHEMA.PLUGINS
 -> WO PLUGIN_TYPE='SPEICHER-ENGINE';

Hinweis: Für Versionen vor MySQL 5.6.1 können Sie den folgenden Befehl verwenden, um den Parameter have_partitioning anzuzeigen. Dieser Parameter wurde in neueren Versionen entfernt.

 mysql> VARIABLEN WIE '%partition%' ANZEIGEN;

5. Mehrere gängige Partitionstabellenmodi im tatsächlichen Kampf

1) Verwenden Sie den RANGE-Partitionsmodus

####Erstellen Sie eine Testtabelle t1 und fügen Sie fast 4 Millionen Datenzeilen ein. Ohne Partitionen dauert es lange, eine bestimmte Bedingung abzufragen

mysql> CREATE TABLE `t1` ( 
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel der Tabelle', 
 `pid` int(10) unsigned NOT NULL COMMENT 'Produkt-ID', 
 `Preis` Dezimalzahl (15,2) NICHT NULL KOMMENTAR 'Stückpreis', 
 `num` int(11) NOT NULL COMMENT 'Kaufmenge', 
 `uid` int(10) unsigned NOT NULL COMMENT 'Kunden-ID', 
 `atime` datetime NICHT NULL KOMMENTAR 'Bestellzeit', 
 `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT 'Änderungszeitpunkt', 
 `isdel` tinyint(4) NICHT NULL STANDARD '0' KOMMENTAR 'Soft-Delete-Flag', 
 PRIMÄRSCHLÜSSEL (`id`,`atime`) 
 ) 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP()); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2016-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2017-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,'2018-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2015-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2016-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2017-05-01 00:00:00'); 
 INSERT INTO t1(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89756,'2018-05-01 00:00:00'); 
 /**********************************Master-Slave-Replikation großer Datenmengen******************************/ 
 mysql> INSERT INTO `t1`(`pid`,`price`,`num`,`uid`,`atime`) SELECT `pid`,`price`,`num`,`uid`,`atime` FROM `t1`; 
 mysql> SELECT * FROM `t1` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP(); 
 1048576 Zeilen im Set (5,62 Sek.) #5,62 Sek. für keine Partitionstabelle

Wenn Sie eine vorhandene Tabelle partitionieren möchten, können Sie die Tabelle mit ALTER TABLE in eine partitionierte Tabelle umwandeln. Dieser Vorgang erstellt eine partitionierte Tabelle, kopiert automatisch die Daten und löscht dann die ursprüngliche Tabelle.

Hinweis: Dies verbraucht eine Menge Serverressourcen (die Verarbeitung von über 4 Millionen Daten dauert mehr als 1 Minute).

mysql> ALTER TABLE t1 PARTITION BY RANGE (JAHR(atime)) 
 -> ( 
 -> PARTITION p0 WERTE WENIGER ALS (2016), 
 -> PARTITION p1 WERTE WENIGER ALS (2017),
 -> PARTITION p2 WERTE WENIGER ALS (2018), 
 -> PARTITION p3 WERTE KLEINER ALS MAXIMALER WERT );
 Abfrage OK, 4194304 Zeilen betroffen (1 Min. 8,32 Sek.)
 mysql> EXPLAIN PARTITIONS SELECT * FROM `t1`; #Partitionsstatus anzeigen+----+----------+----------+-------------+------+---------------+---------+---------+---------+---------+---------+---------+---------+---------+---------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+---------+----------+----------+
 | 1 | EINFACH | t1 | p0,p1,p2,p3 | ALLE | NULL | NULL | NULL | NULL | 4180974 | 100,00 | NULL |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+---------+----------+----------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)

Verwenden Sie dieselbe Abfrage wie oben, um die Ergebnisse zu testen

mysql> SELECT * FROM `t1` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP();
 1048576 Zeilen im Set (4,46 Sek.) #Im Vergleich zur obigen Abfrage ohne Partitionsausführungszeit ist es fast 1 Sekunde weniger
 mysql> EXPLAIN PARTITIONS SELECT * FROM `t1` WHERE `uid`=89757 AND `atime`< CURRENT_TIMESTAMP(); #Die von der Abfrage verwendeten Partitionen anzeigen +----+----------+----------+------------+------+---------------+---------+-----------+---------+---------+---------+---------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+---------+---------+----------+-------------+
 | 1 | SIMPLE | t1 | p0,p1,p2 | ALLE | NULL | NULL | NULL | NULL | 3135804 | 3.33 | Verwenden von „where“ |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+---------+---------+----------+-------------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
Beachten Sie dabei, dass nach der Partitionierung der Tabelle auch die Speicherdateien der Tabelle im Datenordner, in dem MySQL die Daten speichert, in mehrere Dateien aufgeteilt werden.
 -rw-r----- 1 mysql mysql 8,7K 14. Februar 14:49 t1.frm
 -rw-r----- 1 mysql mysql 36M 14. Februar 14:50 t1#P#p0.ibd
 -rw-r----- 1 mysql mysql 64M 14. Februar 14:50 t1#P#p1.ibd
 -rw-r----- 1 mysql mysql 92M 14. Februar 14:50 t1#P#p2.ibd
 -rw-r----- 1 mysql mysql 64M 14. Februar 14:50 t1#P#p3.ibd
In tatsächlichen Produktionsumgebungen wird meist ein anderer Ansatz verwendet: Erstellen Sie eine neue Partitionstabelle, die mit der Originaltabelle identisch ist, exportieren Sie dann die Daten aus der Originaltabelle, importieren Sie sie in die neue Tabelle und erstellen Sie schließlich einen normalen Index.
mysql> CREATE TABLE `t2` ( 
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel der Tabelle', 
 `pid` int(10) unsigned NOT NULL COMMENT 'Produkt-ID', 
 `Preis` Dezimalzahl (15,2) NICHT NULL KOMMENTAR 'Stückpreis', 
 `num` int(11) NOT NULL COMMENT 'Kaufmenge', 
 `uid` int(10) unsigned NOT NULL COMMENT 'Kunden-ID', 
 `atime` datetime NICHT NULL KOMMENTAR 'Bestellzeit', 
 `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT 'Änderungszeitpunkt', 
 `isdel` tinyint(4) NICHT NULL STANDARD '0' KOMMENTAR 'Soft-Delete-Flag', 
 PRIMÄRSCHLÜSSEL (`id`,`atime`) 
 ) 
 
 PARTITION NACH BEREICHSSPALTEN(atime) ( 
 PARTITION p0 WERTE KLEINER ALS ('2016-01-01'),
 PARTITION p1 WERTE KLEINER ALS ('2016-02-01'),
 PARTITION p2 WERTE KLEINER ALS ('2016-03-01'),
 PARTITION p3 WERTE KLEINER ALS ('2016-04-01'),
 PARTITION p4 WERTE KLEINER ALS ('2016-05-01'),
 PARTITION p5 WERTE KLEINER ALS ('2016-06-01'),
 PARTITION p6 WERTE KLEINER ALS ('2016-07-01'),
 PARTITION p7 WERTE KLEINER ALS ('2016-08-01'),
 PARTITION p8 WERTE KLEINER ALS ('2016-09-01'),
 PARTITION p9 WERTE KLEINER ALS ('2016-10-01'),
 PARTITION p10 WERTE KLEINER ALS ('2016-11-01'),
 PARTITION p11 WERTE KLEINER ALS ('2016-12-01'),
 PARTITION p12 WERTE KLEINER ALS ('2017-01-01'),
 PARTITION p13 WERTE KLEINER ALS ('2017-02-01'),
 PARTITION p14 WERTE KLEINER ALS ('2017-03-01'),
 PARTITION p15 WERTE KLEINER ALS ('2017-04-01'),
 PARTITION p16 WERTE KLEINER ALS ('2017-05-01'),
 PARTITION p17 WERTE KLEINER ALS ('2017-06-01'),
 PARTITION p18 WERTE KLEINER ALS ('2017-07-01'),
 PARTITION p19 WERTE KLEINER ALS ('2017-08-01'),
 PARTITION p20 WERTE KLEINER ALS ('2017-09-01'),
 PARTITION p21 WERTE KLEINER ALS ('2017-10-01'),
 PARTITION p22 WERTE KLEINER ALS ('2017-11-01'),
 PARTITION p23 WERTE KLEINER ALS ('2017-12-01'),
 PARTITION p24 WERTE KLEINER ALS ('2018-01-01'),
 PARTITION p25 WERTE KLEINER ALS ('2018-02-01'),
 PARTITION p26 WERTE KLEINER ALS ('2018-03-01'),
 PARTITION p27 WERTE KLEINER ALS ('2018-04-01'),
 PARTITION p28 WERTE KLEINER ALS ('2018-05-01'),
 PARTITION p29 WERTE KLEINER ALS ('2018-06-01'),
 PARTITION p30 WERTE KLEINER ALS ('2018-07-01'),
 PARTITION p31 WERTE KLEINER ALS ('2018-08-01'),
 PARTITION p32 WERTE KLEINER ALS ('2018-09-01'),
 PARTITION p33 WERTE KLEINER ALS ('2018-10-01'),
 PARTITION p34 WERTE KLEINER ALS ('2018-11-01'),
 PARTITION p35 WERTE KLEINER ALS ('2018-12-01'),
 PARTITION p36 WERTE WENIGER ALS MAXIMALER WERT
 );
Hinweis: Der Primärschlüssel der Tabelle ist nur id und das Partitionsfeld ist atime. Hier sollte der Primärschlüssel in id, stsdate gemeinsamer Primärschlüssel geändert werden. Die Partitionstabelle erfordert, dass das Partitionsfeld der Primärschlüssel oder Teil des Primärschlüssels ist!!!
mysql> PARTITIONEN ERKLÄREN SELECT * FROM `t2`\G;
 *************************** 1. Reihe ***************************
 ID: 1
 select_type: EINFACH
 Tabelle: t2
 Partitionen: p0,p1,p2,p3,p4,p5,p6,p7,p8,p9,p10,p11,p12,p13,p14,p15,p16,p17,p18,p19,p20,p21,p22,p23,p24,p25,p26,p27,p28,p29,p30,p31,p32,p33,p34,p35,p36
 Typ: ALLE
 mögliche Schlüssel: NULL
 Schlüssel: NULL
 key_len: NULL
 Ref: NULL
 Reihen: 1
 gefiltert: 100,00
 Extra: NULL
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 ***********************************************Daten einfügen****************************************************
 INSERT INTO `t2`(`pid`,`price`,`num`,`uid`,`atime`) SELECT `pid`,`price`,`num`,`uid`,`atime` FROM `t1`;
 Abfrage OK, 4194304 Zeilen betroffen (1 Min. 18,54 Sek.)
 Datensätze: 4194304 Duplikate: 0 Warnungen: 0
Oder exportieren Sie die Daten und importieren Sie sie anschließend und fügen Sie dann den Index hinzu
mysqldump -u dbname -p --no-create-info dbname t2 > t2.sq

Ändern Sie den Tabellennamen, importieren Sie die Daten, testen Sie sie und löschen Sie die Originaltabelle.

2) Verwenden Sie den LIST-Partitionsmodus (wenn die ursprüngliche Tabelle einen starken Primärschlüssel hat, werden beim Erstellen einer neuen Tabelle der ursprüngliche Primärschlüssel und das Partitionsfeld als gemeinsamer Primärschlüssel erstellt).
mysql> CREATE TABLE `tb01` ( 
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel der Tabelle', 
 `pid` int(10) unsigned NOT NULL COMMENT 'Produkt-ID', 
 `Preis` Dezimalzahl (15,2) NICHT NULL KOMMENTAR 'Stückpreis', 
 `num` int(11) NOT NULL COMMENT 'Kaufmenge', 
 `uid` int(10) unsigned NOT NULL COMMENT 'Kunden-ID', 
 `atime` datetime NICHT NULL KOMMENTAR 'Bestellzeit', 
 `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT 'Änderungszeitpunkt', 
 `isdel` tinyint(4) NICHT NULL STANDARD '0' KOMMENTAR 'Soft-Delete-Flag', 
 PRIMÄRSCHLÜSSEL (`id`,`num`) 
 ); 
 *****************************Testdaten einfügen**********************************************************
 INSERT INTO `tb01`(`pid`,`price`,`num`,`uid`,`atime`) SELECT `pid`,`price`,`num`,`uid`,`atime` FROM `tb`;
 Abfrage OK, 3145728 Zeilen betroffen (46,26 Sek.)
 Datensätze: 3145728 Duplikate: 0 Warnungen: 0
 mysql> ALTER TABLE tb01 PARTITION BY LIST(Anzahl) 
 ( 
 PARTITION pl01 WERTE IN (1,3), 
 PARTITION pl02 WERTE IN (2,4), 
 PARTITION pl03 WERTE IN (5,7), 
 PARTITION pl04 WERTE IN (6,8), 
 PARTITION pl05 WERTE IN (9,10) 
 );
 Abfrage OK, 3145728 Zeilen betroffen (48,86 Sek.)
 Datensätze: 3145728 Duplikate: 0 Warnungen: 0
Die folgenden Dateien werden in der MySQL-Datendatei generiert -rw-r----- 1 mysql mysql 8,7K 15. Februar 11:35 tb01.frm
 -rw-r----- 1 mysql mysql 56M 15. Februar 11:36 tb01#P#pl01.ibd
 -rw-r----- 1 mysql mysql 32M 15. Februar 11:36 tb01#P#pl02.ibd
 -rw-r----- 1 mysql mysql 36M 15. Februar 11:36 tb01#P#pl03.ibd
 -rw-r----- 1 mysql mysql 36M 15. Februar 11:36 tb01#P#pl04.ibd
 -rw-r----- 1 mysql mysql 52M 15. Februar 11:36 tb01#P#pl05.ibd

mysql> PARTITIONEN ERKLÄREN SELECT * FROM `tb01`;
+----+--------------+----------+--------------------------+------+---------------+---------+---------+---------+---------+---------+----------+---------+
| ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
+----+--------------+----------+--------------------------+------+---------------+---------+---------+---------+---------+---------+----------+---------+
| 1 | EINFACH | tb01 | pl01,pl02,pl03,pl04,pl05 | ALLE | NULL | NULL | NULL | NULL | 3136392 | 100,00 | NULL |
+----+--------------+----------+--------------------------+------+---------------+---------+---------+---------+---------+---------+----------+---------+
1 Zeile im Satz, 2 Warnungen (0,00 Sek.)

3) Spaltenaufteilung

Erstellen Sie eine mehrspaltige Partitionstabelle tb02, in der keine Spalte ein gemeinsamer Primärschlüssel ist

mysql> TABELLE ERSTELLEN tb02(
 -> eine Ganzzahl ungleich null,
 -> b int nicht null
 -> )
 -> PARTITION NACH BEREICHSSPALTEN(a,b)(
 -> Partition p0 Werte kleiner als (0,10),
 -> Partition p1 Werte kleiner als (10,20),
 -> Partition p2 Werte kleiner als (10,30),
 -> Partition p3 Werte kleiner als (maxvalue, maxvalue)
 -> );
 mysql> PARTITIONEN ERKLÄREN SELECT * FROM `tb02`; #Ansicht +----+----------+----------+-------------+------+---------------+---------+---------+---------+---------+------+---------+---------+---------+---------+---------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+------+------+------+------+
 | 1 | EINFACH | tb02 | p0,p1,p2,p3 | ALLE | NULL | NULL | NULL | NULL | 1 | 100,00 | NULL |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 mysql> insert into tb02 values ​​​​(11,13); #Testdaten manuell einfügen Abfrage OK, 1 Zeile betroffen (0,01 Sek.)
 mysql> wähle PARTITION_NAME,PARTITION_EXPRESSION,TABLE_ROWS aus information_schema.partitions, wobei table_schema=schema() und table_name='tb02'; 
 +-----------------+----------------------+------------+
 | PARTITIONSNAME | PARTITIONSAUSDRUCK | TABELLENZEILEN |
 +-----------------+----------------------+------------+
 | p0 | `a`,`b` | 0 |
 | p1 | `a`,`b` | 0 |
 | p2 | `a`,`b` | 0 |
 | p3 | `a`,`b` | 1 |
 +-----------------+----------------------+------------+
 4 Reihen im Satz (0,03 Sek.)
4) Hase-Partition

HASH wird hauptsächlich verwendet, um Daten möglichst gleichmäßig auf eine festgelegte Anzahl von Partitionen zu verteilen. Bei der Hash-Partitionierung führt MySQL eine Hash-Funktion auf dem Partitionsschlüssel aus, um zu bestimmen, in welche Partition die Daten gelegt werden sollen. Die HASH-Partitionierung wird in reguläre HASH-Partitionierung und lineare HASH-Partitionierung unterteilt. Erstere verwendet den Modulo-Algorithmus und letztere die lineare Zweierpotenz-Operationsregel.

Tabelle erstellen `tb03` ( 
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel der Tabelle', 
 `pid` int(10) unsigned NOT NULL COMMENT 'Produkt-ID', 
 `Preis` Dezimalzahl (15,2) NICHT NULL KOMMENTAR 'Stückpreis', 
 `num` int(11) NOT NULL COMMENT 'Kaufmenge', 
 `uid` int(10) unsigned NOT NULL COMMENT 'Kunden-ID', 
 `atime` datetime NICHT NULL KOMMENTAR 'Bestellzeit', 
 `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT 'Änderungszeitpunkt', 
 `isdel` tinyint(4) NICHT NULL STANDARD '0' KOMMENTAR 'Soft-Delete-Flag', 
 PRIMÄRSCHLÜSSEL (`id`)
 ) 
 PARTITION BY HASH(id)-Partitionen 4;
 Fügen Sie 2 Datenzeilen ein:
 INSERT INTO tb03(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP()); 
 INSERT INTO tb03(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP());
 mysql> Partitionen erklären, wählen Sie * aus tb03, wobei ID=1;
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | 1 | EINFACH | tb03 | p1 | const | PRIMARY | PRIMARY | 4 | const | 1 | 100,00 | NULL |
 +----+----------+----------+---------+-----------+---------------+--------+---------+---------+-------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 mysql> Partitionen erklären, wählen Sie * aus tb03, wobei ID=2;
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | 1 | EINFACH | tb03 | p2 | const | PRIMARY | PRIMARY | 4 | const | 1 | 100,00 | NULL |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
Hinweis: Obwohl die HASH-Partitionierung die Daten möglichst gleichmäßig auf jede Partition verteilt und so die Abfrageeffizienz verbessert, erhöht sie den Aufwand für die Partitionsverwaltung. Wenn es beispielsweise vorher 5 Partitionen gab und eine weitere Partition hinzugefügt werden soll, ändert sich der Algorithmus von mod(expr,5) zu (expr,6), und die meisten Daten in den ursprünglichen 5 Partitionen müssen neu berechnet und neu partitioniert werden. Obwohl die Verwendung einer linearen HASH-Partitionierung die Kosten der Partitionsverwaltung reduziert, sind die Daten nicht so gleichmäßig verteilt wie bei regulärem HASH.

5) KEY-Partition

Die KEY-Partitionierung ähnelt der HASH-Partitionierung, Sie können jedoch keine benutzerdefinierten Ausdrücke verwenden. Sie unterstützt jedoch viele Arten von Partitionsschlüsseln, mit Ausnahme von Texttypen wie Text und Blob.

Tabelle erstellen `tb04` ( 
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT 'Primärschlüssel der Tabelle', 
 `pid` int(10) unsigned NOT NULL COMMENT 'Produkt-ID', 
 `Preis` Dezimalzahl (15,2) NICHT NULL KOMMENTAR 'Stückpreis', 
 `num` int(11) NOT NULL COMMENT 'Kaufmenge', 
 `uid` int(10) unsigned NOT NULL COMMENT 'Kunden-ID', 
 `atime` datetime NICHT NULL KOMMENTAR 'Bestellzeit', 
 `utime` int(10) unsigned NOT NULL DEFAULT 0 COMMENT 'Änderungszeitpunkt', 
 `isdel` tinyint(4) NICHT NULL STANDARD '0' KOMMENTAR 'Soft-Delete-Flag', 
 PRIMÄRSCHLÜSSEL (`id`)
 ) 
 PARTITION NACH KEY(id)-Partitionen 4;
 Fügen Sie 2 Datenzeilen ein:
 INSERT INTO tb04(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP()); 
 INSERT INTO tb04(`pid`,`price`,`num`,`uid`,`atime`) VALUES(1,12.23,1,89757,CURRENT_TIMESTAMP());
 #Verwenden Sie die Ausführungsaufgabe, um die Partitionen zu überprüfen, in denen die Datensätze liegen.mysql> Explain Partitions Select * from tb04 Where ID=1;
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | 1 | EINFACH | tb04 | p0 | const | PRIMARY | PRIMARY | 4 | const | 1 | 100,00 | NULL |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 mysql> Partitionen erklären, wählen Sie * aus tb04, wobei ID=2;
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 | 1 | EINFACH | tb04 | p3 | const | PRIMARY | PRIMARY | 4 | const | 1 | 100,00 | NULL |
 +----+----------+----------+---------+-------+---------------+--------+---------+---------+---------+-------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
6) Partitionstabellenverwaltung

Es wird empfohlen, Partitionen in einer Produktionsumgebung nicht zu ändern. Alter liest die Daten in der alten Tabelle und speichert sie in der neu definierten Tabelle. Der Prozess-E/A wird sehr groß sein und die gesamte Tabelle wird gesperrt.

*1* Partition löschen: Beispiel: tb01 Tabelle oben

--Die p05-Partitionsabfragedaten werden nicht gelöscht, hauptsächlich um zu überprüfen, ob die Partitionsdaten beim Löschen gelöscht werden

mysql> wähle count(1) aus tb01, wobei num=10;
 +----------+
 | Anzahl(1) |
 +----------+
 |524288|
 +----------+
 1 Zeile im Satz (0,37 Sek.)
 mysql> alter table tb01 drop partition pl05; #Löschen Sie die Partition pl05. Um beispielsweise mehrere Partitionen gleichzeitig zu löschen, führen Sie alter table tb01 drop partition pl04,pl05 aus.
 Abfrage OK, 0 Zeilen betroffen (0,06 Sek.)
 Datensätze: 0 Duplikate: 0 Warnungen: 0
 mysql> select count(1) from tb01 where num=10; #Die Ergebnisdaten werden ebenfalls gelöscht, bitte gehen Sie mit Vorsicht vor+----------+ 
 | Anzahl(1) |
 +----------+
 | 0 |
 +----------+
 1 Zeile im Satz (0,01 Sek.）
Hinweis: Beim Löschen einer Partition werden Daten gelöscht. Gehen Sie daher vorsichtig vor. Hash- oder Schlüsselpartitionen können nicht gelöscht werden.

*2*Partition hinzufügen

Hinweis: Der Wert der neuen Partition darf keinen Wert in der Werteliste einer vorhandenen Partition enthalten, da sonst ein Fehler gemeldet wird. Die neu hinzugefügte Partition organisiert die Daten neu und die Originaldaten gehen nicht verloren. Nachdem der MAXVALUE-Wert festgelegt wurde, können Partitionen nicht direkt hinzugefügt werden. Die obige t1-Tabelle wird beispielsweise als Beispiel verwendet.

mysql> ALTER TABLE t1 ADD PARTITION (PARTITION P4 WERTE KLEINER ALS (2018)); 
 FEHLER 1481 (HY000): MAXVALUE kann nur in der letzten Partitionsdefinition verwendet werden
 Beispiel: Fügen Sie die aus tb01mysql gelöschte Partition pl05 hinzu> ALTER TABLE tb01 ADD PARTITION(PARTITION pl05 VALUES IN (9,10));
 Abfrage OK, 0 Zeilen betroffen (0,05 Sek.)
 Datensätze: 0 Duplikate: 0 Warnungen: 0
*3* Zerlegung von Partitionen

Hinweis: Mit dem Schlüsselwort „Partition reorganisieren“ können einige oder alle Partitionen einer Tabelle geändert werden, ohne dass Daten verloren gehen. Der Gesamtbereich der Partitionen sollte vor und nach der Zerlegung konsistent sein.

Beispiel:

mysql> Tabelle tb05 erstellen
 -> (dep int,
 -> Geburtsdatum,
 -> Gehalt int
 -> )
 -> Aufteilung nach Bereich (Gehalt)
 -> (
 -> Partition p1 Werte kleiner als (1000),
 -> Partition p2 Werte kleiner als (2000),
 -> Partition p3 Werte kleiner als Maxwert
 -> );
 Abfrage OK, 0 Zeilen betroffen (0,08 Sek.)
 ****Fügen Sie einen Testdatensatz einmysql> insert tb05 values(1,'2016-03-06',80);
 Abfrage OK, 1 Zeile betroffen (0,01 Sek.)
 mysql>alter table tb05 reorganisiere Partition p1 in(
 Partition p01-Werte kleiner als (100),
 Partition p02 Werte kleiner als (1000)
 ); ----Es gehen keine Daten verlorenmysql> Partitionen erklären select * from tb05 where salary=80; #Überprüfen Sie, ob es auf die neue Partition p01 gefallen ist+----+----------+----------+------------+-----------+---------+---------+---------+---------+---------+---------+---------+---------+----------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+
 | 1 | SIMPLE | tb05 | p01 | ALLE | NULL | NULL | NULL | NULL | 1 | 100,00 | Verwenden von „where“ |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
*4*Partitionen zusammenführen

Hinweis: Führen Sie 2 Partitionen zu einer zusammen.

Beispiel: Zusammenführen von p01 und p02 in der obigen Tabelle tb05 zu p1

mysql> alter table tb05 reorganize partition p01,p02 into(partition p1 values ​​less than (1000)); --Keine Datenverlustabfrage OK, 0 Zeilen betroffen (0,05 Sek.)
 Datensätze: 0 Duplikate: 0 Warnungen: 0
 mysql> Partitionen erklären, wählen Sie * aus tb05, wobei Gehalt=80 ist;
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+
 | 1 | SIMPLE | tb05 | p1 | ALL | NULL | NULL | NULL | NULL | 1 | 100,00 | Verwenden von „where“ |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+---------+----------+----------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
*5* Definieren Sie die Hash-Partitionstabelle neu:

Beim Neudefinieren von RANGE- und LIST-Partitionen können Sie nur benachbarte Partitionen neu definieren und keine Partitionen überspringen. Der neu definierte Partitionsbereich muss mit dem ursprünglichen Partitionsbereich übereinstimmen und der Partitionstyp kann nicht geändert werden.

Beispiel:

mysql> PARTITIONEN ERKLÄREN SELECT * FROM `tb03`;
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+------+------+------+------+
 | 1 | EINFACH | tb03 | p0,p1,p2,p3 | ALLE | NULL | NULL | NULL | NULL | 4 | 100,00 | NULL |
 +----+----------+----------+----------+------+---------------+-----------+---------+---------+------+---------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 mysql> Tabelle tb03-Partition nach Hash(ID)-Partitionen 8 ändern; #Kein Datenverlust. Abfrage OK, 4 Zeilen betroffen (0,13 Sek.)
 Datensätze: 4 Duplikate: 0 Warnungen: 0
 mysql> PARTITIONEN ERKLÄREN SELECT * FROM `tb03`;
 +----+--------------+----------+-------------------------+------+---------------+---------+---------+------+---------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+--------------+----------+-------------------------+------+---------------+---------+---------+------+---------+------+------+------+------+
 | 1 | EINFACH | tb03 | p0,p1,p2,p3,p4,p5,p6,p7 | ALLE | NULL | NULL | NULL | NULL | 1 | 100,00 | NULL |
 +----+--------------+----------+-------------------------+------+---------------+---------+---------+------+---------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,02 Sek.)
*6* Alle Partitionen der Tabelle löschen:

Beispiel: Alle Partitionen der Tabelle tb03 löschen

mysql> Tabelle tb03 ändern, Partitionierung entfernen; #Kein Datenverlust. Abfrage OK, 4 Zeilen betroffen (0,07 Sek.)
 Datensätze: 4 Duplikate: 0 Warnungen: 0
 mysql> PARTITIONEN ERKLÄREN SELECT * FROM `tb03`;
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+------+------+------+------+
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+------+------+------+------+
 | 1 | EINFACH | tb03 | NULL | ALLE | NULL | NULL | NULL | NULL | 4 | 100,00 | NULL |
 +----+----------+----------+---------+------+---------------+---------+---------+------+---------+------+------+------+------+------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)

*7* Defragmentieren Sie die Partition

Hinweis: Wenn Sie eine große Anzahl Zeilen aus einer Partition löschen oder viele Änderungen an einer Zeile mit variabler Länge vornehmen (also einer Spalte vom Typ VARCHAR, BLOB oder TEXT), können Sie mit ALTER TABLE ... OPTIMIZE PARTITION ungenutzten Speicherplatz freigeben und die Partitionsdatendatei defragmentieren.
 ALTER TABLE tb03 Partition p1,p2 optimieren;
*8* Analysepartition:
Lesen und Speichern der Schlüsselverteilung einer Partition.

 mysql> ALTER TABLE tb04 CHECK-Partition p1,p2;
 +--------------+----------+----------+----------+
 | Tabelle | Op | Nachrichtentyp | Nachrichtentext |
 +--------------+----------+----------+----------+
 | testsms.tb04 | prüfen | Status | OK |
 +--------------+----------+----------+----------+
 1 Zeile im Satz (0,01 Sek.)

*9* Partitionen prüfen:

Sie können Partitionen auf die gleiche Weise überprüfen, wie Sie CHECK TABLE für eine nicht partitionierte Tabelle verwenden würden. Mit diesem Befehl kann tb04 feststellen, ob die Daten oder Indizes in den Partitionen p1 und p2 der Tabelle beschädigt wurden. Wenn dies passiert, verwenden Sie „ALTER TABLE … REPAIR PARTITION“, um die Partition zu reparieren.

mysql> ALTER TABLE tb04 CHECK-Partition p1,p2;
 +--------------+----------+----------+----------+
 | Tabelle | Op | Nachrichtentyp | Nachrichtentext |
 +--------------+----------+----------+----------+
 | testsms.tb04 | prüfen | Status | OK |
 +--------------+----------+----------+----------+
 1 Zeile im Satz (0,01 Sek.)

6. Einfache Anwendung in der Praxis

Szenario: Zuvor gab es eine große Datentabelle SmsSend (Beispieltabelle, ca. 28 Millionen Zeilen) ohne Partitionen. Der statistische Prozess war sehr zeitaufwändig. Erwägen Sie die Verwendung von Jahrespartitionen und die Sicherung der historischen Datenbank, um die Daten ab 2014 in die neue Sicherungstabelle smssendbak zu übertragen. Wenn die Online-Neudefinition zu zeitaufwändig ist, kann die Austauschverarbeitung genutzt werden!

1) Sehen Sie sich die aktuelle SmsSend-Tabelle an

mysql> SHOW CREATE TABLE SmsSend; #Erstellungsinformationen anzeigen, keine Partitionierung | SmsSend | CREATE TABLE `SmsSend` (
 `Guid` char(36) NOT NULL COMMENT 'Eindeutiger Bezeichner',
 `SID` varbinary(85) DEFAULT NULL COMMENT 'Eindeutige Verkäufernummer',
 `Mobile` longtext NOT NULL COMMENT 'Mobile Rufnummer erhalten (getrennt durch ","),
 `SmsContent` varchar(500) NOT NULL COMMENT 'SMS-Inhalt',
 `SmsCount` int(11) NOT NULL DEFAULT '1' COMMENT 'Anzahl der Nachrichten',
 `Status` int(11) NOT NULL COMMENT 'Aktueller Status (0, warte auf Senden; 1, erfolgreich gesendet; -1, Senden fehlgeschlagen)',
 `SendChanelKeyName` varchar(20) DEFAULT NULL COMMENT 'Sendekanal-ID',
 `SendTime` datetime NICHT NULL KOMMENTAR 'Senden erfolgreicher Zeitpunkt',
 `SendType` int(11) NOT NULL DEFAULT '1' COMMENT 'SMS-Versandtyp (1, Einzelversand; 2, Gruppenversand)',
 `ReceiveTime` datetime DEFAULT NULL COMMENT 'Die Zeit, zu der der Antwortbericht empfangen wurde',
 `Priorität` int(11) NICHT NULL STANDARD '0' KOMMENTAR 'Priorität',
 `Benutzerkonto` varchar(50) DEFAULT NULL COMMENT 'Operator',
 `ChainStoreGuid` char(36) DEFAULT NULL COMMENT 'Eindeutige Kennung des Vorgangsspeichers',
 "Relationkey" longtext comment 'Antwortbericht Association Identifier ",
 "Meno" Textkommentare "Notizen",
 "Isfree" bit (1) nicht null Standard B'0 'Kommentar' ist es kostenlos? "
 ) ENGINE=InnoDB STANDARD-CHARSET=utf8mb4 |
 MySQL> Wählen Sie Count (*) aus SMSSend;
 | ANZAHL(*) |
 +----------+
 | 28259803 |
 +----------+
 1 Zeile in Set (1 min 52,60 Sek.)
 #Es ist zu erkennen, dass die Online -Partitionierung langsam ist und die Leistung unter großen Data tablesmysql> Änderung der Tabelle SMSSend -Partition nach Bereich (Jahr (SendTime)) verbraucht. 
 -> (
 -> Partition PY01 -Werte weniger als (2015),
 -> Partition PY02 -Werte weniger als (2016),
 -> Partition PY03 -Werte weniger als (2017)); 
 Abfrage OK, 28259803 Zeilen betroffen (20 min 36,05 Sekunden)
 Aufzeichnungen: 28259803 Duplikate: 0 Warnungen: 0
 #Überprüfen Sie die Anzahl der Partitionsabsätze mysql> count (1) aus SMSSend Partition (PY01);
 +----------+
 | Anzahl(1) |
 +----------+
 | 10 |
 +----------+
 1 Zeile im Satz (0,00 Sek.)
 MySQL> Erklären Sie Partitionen aus * aus smSSend Where SendTime <'2015-01-01';
 | ID | Auswahltyp | Tabelle | Partitionen | Typ | mögliche Schlüssel | Schlüssel | Schlüssellänge | Ref. | Zeilen | gefiltert | Extra |
 +----+-------------+----------+------------+------+---------------+------+----------+------+------+----------+-------------+
 |
 +----+-------------+----------+------------+------+---------------+------+----------+------+------+----------+-------------+
 1 Zeile im Satz, 2 Warnungen (0,00 Sek.)
 MySQL> Wählen Sie Graf (1) aus SMSSend Partition (PY02);
 +----------+
 | Anzahl(1) |
 +----------+
 | 10 |
 +----------+
 1 Zeile in Set (0,00 Sek.）

2) Erstellen Sie schnell eine SMSSendbak -Sicherungstabelle mit der gleichen Struktur wie die ursprüngliche SMSSend -Tabelle und löschen Sie alle Partitionen der Sicherungstabelle

MySQL> TABLE SMSSENDBAK LIEBEN SMSSEND;
 Abfrage OK, 0 Zeilen betroffen (0,14 Sek.)
 MySQL> Alter Tabelle SMSSENDBAK Entfernen Sie die Partitionierung;
 Abfrage OK, 0 Zeilen betroffen (0,19 Sek.)
 Datensätze: 0 Duplikate: 0 Warnungen: 0

3) verwenden

SMSENSDBAK -Aufzeichnungen

MySQL> Alter Tabelle SMSSend Exchange Partition PY01 mit Tabelle SMSSendbak;
 Abfrage OK, 0 Zeilen betroffen (0,13 Sek.)
 MySQL> Wählen Sie Graf (1) aus SMSSend Partition (PY01);
 | Anzahl(1) |
 +----------+
 | 0 |
 +----------+
 1 Zeile im Satz (0,00 Sek.)
 MySQL> Wählen Sie Count (1) aus SMSSendBak;
 |
 +----------+
 | 10 |
 +----------+
 1 Zeile im Satz (0,00 Sek.)
***********
 Erstellen Sie eine grundlegende Testtabelle:
 TABELLE ERSTELLEN `tb` ( 
 `id` int (10) Unsigniert nicht null auto_increment Kommentar 'Tabelle Primärschlüssel', 
 "PID` int (10) Unsigned NOLL NULL Kommentar" Produkt -ID ", 
 `Price` Dezimal (15,2) Nicht null Kommentar 'Einheit Preis', 
 `num` int (11) Nicht null Kommentar 'Kaufmenge', 
 "uid" int (10) nicht signiert null comment "customer id", 
 `athime` datetime nicht null kommentieren 'Bestellzeit', 
 `utime` int (10) nicht signiert nicht null Standard 0 Kommentar 'Änderungszeit', 
 "isdel" Tinyint (4) Nicht null Standard '0' Kommentar 'Soft Delete Flag', 
 ) ;
 Daten einfügen:
 Einfügen in TB (`pid`,` price`, `num`,` uid`, `atime`) Werte (1,12,23,1,89757, current_timestamp ()); 
 Einfügen in TB ("PID`," Price "," num "," uid "," atime ") Werte (1,12,23,1.89757," 2016-05-01 00:00:00 "); 
 Einfügen in TB (`pid`,` Price`, `num`,` uid`, `ath`) Werte (1,12,23,1.89757, '2017-05-01 00:00:00'); 
 Einfügen in TB (`pid`,` Price`, `num`,` uid`, `ath`) Werte (1,12,23,1.89757, '2018-05-01 00:00:00'); 
 Einfügen in TB (`pid`,` price`, `num`,` uid`, `atime`) Werte (1,12,23,1.89756, '2015-05-01 00:00:00'); 
 Einfügen in TB ("PID`," Price "," num "," uid "," atime ") Werte (1,12,23,1.89756", "2016-05-01 00:00:00"); 
 Einfügen in TB (`pid`,` price`, `num`,` uid`, `ath`) Werte (1,12,23,1.89756, '2017-05-01 00:00:00'); 
 
 *************
 In `tb` (` pid`, `price`,` num`, `uid`,` atime`) eingeben `pid`,` price`, `num`,` uid`, `ath` von` tb`;
**** HINWEIS: Wenn Sie die selbstauflösende Primär-Key-ID löschen möchten (während des Änderungsprozesses, wird empfohlen, die Datenbank in schreibgeschützt zu ändern), sollten Sie folgende Folgendes ändern:
  TABEL TB Änderung ID int (10);

Das Obige ist der vollständige Inhalt dieses Artikels. Ich hoffe, er wird für jedermanns Studium hilfreich sein. Ich hoffe auch, dass jeder 123WORDPRESS.COM unterstützen wird.

Das könnte Sie auch interessieren:
  • MySQL Best Practices: Grundlegende Arten von Partitionstabellen
  • Grundlegendes Einführungstutorial zu MySQL-Partitionstabellen
  • Best Practices-Handbuch für partitionierte MySQL-Tabellen
  • Richtiger Einsatz von MySQL-Partitionstabellen
  • Detaillierte Erläuterung der Einschränkungen und Beschränkungen von MySQL-partitionierten Tabellen
  • Verwaltung und Wartung von Mysql-Partitionstabellen
  • MySQL-Optimierungspartitionstabelle
  • Eine Methode zur Verbesserung der Leistung mithilfe von MySQL -Partitionstabellen in Schienen
  • MySQL -Tutorial zur Verwendung von Partitionstabellen (Partitionstabellen löschen)
  • Detaillierte Erklärung der MySQL-Partitionstabelle

<<:  So stellen Sie ein Vue-Projekt unter Nginx bereit

>>:  Vue verwendet v-model, um den gesamten Prozess der El-Paginierungskomponenten zu kapseln

Artikel empfehlen

Erfahrung mit parallelen React-Funktionen (gleichzeitiger Front-End-Modus)

React ist eine Open-Source-JavaScript-Bibliothek,...

Eine kurze Diskussion über die Simulation von Multithread- und Multiprozess-Abstürzen in Linux

Abschluss: Wenn in einer Multithread-Umgebung ein...

Vue nutzt Baidu Maps zur Realisierung der Stadtpositionierung

In diesem Artikel wird der spezifische Code von V...

Sechs Methoden zur Nginx-Optimierung

1. Optimieren Sie die Nginx-Parallelität [root@pr...

Detaillierte Erklärung der Beziehung zwischen Linux- und GNU-Systemen

Inhaltsverzeichnis Was ist das Linux-System, das ...

So stellen Sie Tencent Cloud Server von Grund auf bereit

Da dies mein erster Beitrag ist, weisen Sie mich ...

Die benutzerdefinierte Vue-Komponente implementiert eine bidirektionale Bindung

Szenario: Die von uns häufig verwendeten Interakt...

Nach dem Klickereignis des HTML-Hyperlinks a wird zur Adresse gesprungen, auf die href zeigt.

Manchmal müssen wir den Hyperlink <a> anstel...

Detaillierte Schritte zur Installation und Konfiguration von MySQL 5.7

1. MySQL herunterladen 1. Melden Sie sich auf der...

Eine einfache Möglichkeit zum Erstellen einer Docker-Umgebung

Lassen Sie uns zunächst verstehen, was Docker ist...

So implementieren Sie eine Paging-Abfrage in MySQL

SQL-Paging-Abfrage:Hintergrund Im System des Unte...

Schritte zum Upgrade des Ubuntu 16.04-Kernels

1. Umwelt Ubuntu 16.04 läuft auf einer virtuellen...

Lösen Sie das Problem der Containerverwaltung mit Docker Compose

Im Docker-Design führt ein Container nur eine Anw...

Natives JS zum Erreichen von Spezialeffekt-Meldungsfeldern

In diesem Artikel wird ein Nachrichtenfeld mit Sp...

So verwenden Sie border-image, um Beispielcode für Textblasenränder zu implementieren

Während der Entwicklungstätigkeit bin ich auf ein...