MySQL-Datenbank Shell import_table Datenimport

MySQL-Datenbank Shell import_table Datenimport

MySQL Shell import_table Datenimport

1. Einführung in import_table

In dieser Ausgabe stellen wir ein effizientes Datenimporttool vor, import_table im MySQL Shell-Toolset. Der vollständige Name des Tools lautet Parallel Table Import Utility. Wie der Name schon sagt, unterstützt es den gleichzeitigen Datenimport. Das Tool verfügt nach MySQL Shell Version 8.0.23 über umfassendere Funktionen. Im Folgenden sind die Kernfunktionen des Tools aufgeführt

  • Deckt grundsätzlich alle Funktionen von MySQL Data Load ab und kann als Ersatz verwendet werden
  • Gleichzeitiger Import wird standardmäßig unterstützt (unterstützt benutzerdefinierte Blockgröße)
  • Unterstützt Platzhalterübereinstimmung, um mehrere Dateien gleichzeitig in eine Tabelle zu importieren (sehr gut geeignet, um Daten mit derselben Struktur in einer Tabelle zusammenzufassen)
  • Unterstützt Geschwindigkeitsbegrenzungen (sehr gut geeignet für Szenarien mit hohen Bandbreitenanforderungen)
  • Unterstützt die Verarbeitung komprimierter Dateien
  • Unterstützt den Import in MySQL 5.7 und höher

2. Beispiele für die Funktion „Daten laden“ und „Tabelle importieren“

Dieser Abschnitt enthält Befehlsbeispiele für dieselben Funktionen wie „Tabelle importieren“ und „Daten laden“. Wir verwenden weiterhin die Beispieldaten der Mitarbeitertabelle als Beispiel, um das umfassende Szenario des Ladens von MySQL-Daten zu demonstrieren.

  • Importieren Sie Daten in benutzerdefinierter Reihenfolge
  • Datenfunktionsverarbeitung
  • Benutzerdefinierter Datenwert

Die Beispieldaten lauten wie folgt:

[root@10-186-61-162 tmp]# Katze Mitarbeiter_01.csv
"10001","1953-09-02","Georgi","Facello","M","1986-06-26"
"10003","1959-12-03","Parto","Bamford","M","1986-08-28"
"10002","1964-06-02","Bezalel","Simmel","F","1985-11-21"
"10004","1954-05-01","Christian","Koblick","M","1986-12-01"
"10005","1955-01-21","Kyoichi","Maliniak","M","1989-09-12"
"10006","1953-04-20","Anneke","Preusig","F","1989-06-02"
"10007","1957-05-23","Tzvetan","Zielinski","F","1989-02-10"
"10008","19.02.1958","Saniya","Kalloufi","M","15.09.1994"
"10009","1952-04-19","Sumant","Peac","F","1985-02-18"
"10010","1963-06-01","Duangkaew","Piveteau","F","1989-08-24"

Beispiel einer Tabellenstruktur:

 10.186.61.162:3306 Mitarbeiter SQL > desc emp;
+-------------+------------------+------+-----+---------+---------+-------+
| Feld | Typ | Null | Schlüssel | Standard | Extra | 
+-------------+------------------+------+-----+---------+---------+-------+
| emp_no | int | NEIN | PRI | NULL | |
| Geburtsdatum | Datum | NEIN | | NULL | |
| Vorname | varchar(14) | NEIN | | NULL | |
| Nachname | varchar(16) | NEIN | | NULL | |
| full_name | varchar(64) | JA | | NULL | | -- Neu hinzugefügtes Feld in der Tabelle, existiert nicht in der exportierten Datendatei | gender | enum('M','F') | NEIN | | NULL | |
| Einstellungsdatum | Datum | NEIN | | NULL | |
| modify_date | datetime | JA | | NULL | | -- Der Tabelle wird ein neues Feld hinzugefügt, das in der exportierten Datendatei nicht vorhanden ist.| delete_flag | varchar(1) | JA | | NULL | | -- Der Tabelle wird ein neues Feld hinzugefügt, das in der exportierten Datendatei nicht vorhanden ist.+-------------+---------------+------+-----+---------+---------+

2.1 Datenimport mit „Load Data“

Daten in Datei laden '/data/mysql/3306/tmp/employees_01.csv'
in die Tabelle employee.emp
Zeichensatz utf8mb4
Felder, die mit ',' abgeschlossen sind
umschlossen von '"'
Zeilen, die mit '\n' beendet sind
(@C1,@C2,@C3,@C4,@C5,@C6)
setze emp_no=@C1,
    Geburtsdatum=@C2,
    Vorname=Obername(@C3),
    Nachname=Untername(@C4),
    vollständiger_name=concat(Vorname,' ',Nachname),
    Geschlecht=@C5,
    Einstellungsdatum=@C6 ,
    change_date = jetzt(),
    delete_flag=wenn(Einstellungsdatum<'1988-01-01','J','N');

2.2 Datenimport mit import_table

util.import_table(
    [
        "/data/mysql/3306/tmp/employees_01.csv",
    ],
    {
        "Schema": "Mitarbeiter", 
        "Tabelle": "emp",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "columns": [1,2,3,4,5,6], ## Verwende so viele Seriennummern wie Spalten in der Datei vorhanden sind "decodeColumns": {
            "emp_no": "@1", ## entspricht der ersten Spalte in der Datei "Birth_date": "@2", ## entspricht der zweiten Spalte in der Datei "First_name": "Upper (@3)" "concat (@3, '',@4)", ## verschmilzt die dritte und vierte Spalte in der Datei, um den Feldwert in der Tabelle "Geschlecht" zu generieren, ## entspricht der fünften Spalte in der Datei "Hire_date": "@6", ## ## ## # # # # # # der fieldate "modify_date": ":" now "" "" "" "": "now" "" "" "" ":" now "" "" "" "" ":" now "" "" "" "" "": "now" "" "" "" if (@6 <'1988-01-01', 'y', 'n') "## machen ein logisches Urteil, das auf der sechsten Spalte in der Datei basiert, und generieren den entsprechenden Feldwert in der Tabelle}
    })

3. import_table-spezifische Funktionen

3.1 Mehrfachdateiimport (Fuzzy Matching)

## Vor dem Importieren habe ich 3 separate Mitarbeiterdateien generiert und die exportierten Strukturen sind konsistent [root@10-186-61-162 tmp]# ls -lh
Gesamtnutzung: 1,9 G
-rw-r----- 1 mysql mysql 579 24. März 19:07 employees_01.csv
-rw-r----- 1 mysql mysql 584 24. März 18:48 employees_02.csv
-rw-r----- 1 mysql mysql 576 24. März 18:48 employees_03.csv
-rw-r----- 1 mysql mysql 1,9 G 26. März 17:15 sbtest1.csv

## Importbefehl, bei dem employees_* für Fuzzy-Matching verwendet wird util.import_table(
    [
        "/data/mysql/3306/tmp/employees_*",
    ],
    {
        "Schema": "Mitarbeiter", 
        "Tabelle": "emp",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "columns": [1,2,3,4,5,6], ## Verwende so viele Seriennummern wie Spalten in der Datei vorhanden sind "decodeColumns": {
            "emp_no": "@1", ## entspricht der ersten Spalte in der Datei "Birth_date": "@2", ## entspricht der zweiten Spalte in der Datei "First_name": "Upper (@3)" "concat (@3, '',@4)", ## verschmilzt die dritte und vierte Spalte in der Datei, um den Feldwert in der Tabelle "Geschlecht" zu generieren, ## entspricht der fünften Spalte in der Datei "Hire_date": "@6", ## ## ## # # # # # # der fieldate "modify_date": ":" now "" "" "" "": "now" "" "" "" ":" now "" "" "" "" ":" now "" "" "" "" "": "now" "" "" "" if (@6 <'1988-01-01', 'y', 'n') "## machen ein logisches Urteil, das auf der sechsten Spalte in der Datei basiert, und generieren den entsprechenden Feldwert in der Tabelle}
    })
    
## Importbefehl, in dem der Pfad der zu importierenden Datei eindeutig angegeben wird util.import_table(
    [
        "/data/mysql/3306/tmp/employees_01.csv",
        "/data/mysql/3306/tmp/employees_02.csv",
        "/data/mysql/3306/tmp/employees_03.csv"
    ],
    {
        "Schema": "Mitarbeiter", 
        "Tabelle": "emp",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "columns": [1,2,3,4,5,6], ## Verwende so viele Seriennummern wie Spalten in der Datei vorhanden sind "decodeColumns": {
            "emp_no": "@1", ## entspricht der ersten Spalte in der Datei "Birth_date": "@2", ## entspricht der zweiten Spalte in der Datei "First_name": "Upper (@3)" "concat (@3, '',@4)", ## verschmilzt die dritte und vierte Spalte in der Datei, um den Feldwert in der Tabelle "Geschlecht" zu generieren, ## entspricht der fünften Spalte in der Datei "Hire_date": "@6", ## ## ## # # # # # # der fieldate "modify_date": ":" now "" "" "" "": "now" "" "" "" ":" now "" "" "" "" ":" now "" "" "" "" "": "now" "" "" "" if (@6 <'1988-01-01', 'y', 'n') "## machen ein logisches Urteil, das auf der sechsten Spalte in der Datei basiert, und generieren den entsprechenden Feldwert in der Tabelle}
    })

3.2 Gleichzeitiger Import

Bevor wir mit dem gleichzeitigen Importieren experimentieren, erstellen wir eine 10 Millionen sbtest1-Tabelle (ca. 2G Daten), um die Parallelität zu simulieren. Der Parameter import_table verwendet Threads als Parallelitätskonfiguration und der Standardwert ist 8 Parallelität.

## Exportieren Sie die für den Test benötigten sbtest1-Daten [root@10-186-61-162 tmp]# ls -lh
Gesamtnutzung: 1,9 G
-rw-r----- 1 mysql mysql 579 24. März 19:07 employees_01.csv
-rw-r----- 1 mysql mysql 584 24. März 18:48 employees_02.csv
-rw-r----- 1 mysql mysql 576 24. März 18:48 employees_03.csv
-rw-r----- 1 mysql mysql 1,9 G 26. März 17:15 sbtest1.csv

## Aktivieren Sie 8 Threads gleichzeitig util.import_table(
    [
        "/data/mysql/3306/tmp/sbtest1.csv",
    ],
    {
        "Schema": "Demo", 
        "Tabelle": "sbtest1",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "Threads": "8"
    })

3.3 Einfuhrmengenkontrolle

Sie können maxRate und Threads verwenden, um die Importdaten jedes gleichzeitigen Threads zu steuern. Wenn die aktuelle Konfiguration beispielsweise 4 Threads hat und die Rate jedes Threads 2 M/s beträgt, wird das Maximum 8 M/s nicht überschreiten.

util.import_table(
    [
        "/data/mysql/3306/tmp/sbtest1.csv",
    ],
    {
        "Schema": "Demo", 
        "Tabelle": "sbtest1",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "Threads": "4",
        "maxRate": "2M"
    })

3.4 Benutzerdefinierte Blockgröße

Die Standardblockgröße beträgt 50 MB. Wir können die Blockgröße anpassen, um die Transaktionsgröße zu verringern. Wenn wir beispielsweise die Blockgröße auf 1 MB anpassen, wird auch die Datenmenge, die jedes Mal von jedem Thread importiert wird, entsprechend reduziert.

util.import_table(
    [
        "/data/mysql/3306/tmp/sbtest1.csv",
    ],
    {
        "Schema": "Demo", 
        "Tabelle": "sbtest1",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4",
        "Threads": "4",
        "bytesPerChunk": "1M",
        "maxRate": "2M"
    })

4. Leistungsvergleich zwischen „Load Data“ und „import_table“

  • Verwenden Sie dieselbe Bibliothekstabelle
  • Es erfolgt keine spezielle Verarbeitung der Daten. Sie werden einfach so importiert, wie sie sind
  • Ändern Sie die Standardparameter nicht, geben Sie nur die erforderlichen Parameter an.
-- Daten laden-Anweisung lädt Daten in Datei '/data/mysql/3306/tmp/sbtest1.csv'
in Tabelle demo.sbtest1
Zeichensatz utf8mb4
Felder, die mit ',' abgeschlossen sind
umschlossen von '"'
Zeilen, die mit '\n' beendet sind

-- import_table-Anweisung util.import_table(
    [
        "/data/mysql/3306/tmp/sbtest1.csv",
    ],
    {
        "Schema": "Demo", 
        "Tabelle": "sbtest1",
        "Dialekt": "csv-unix",
        "skipRows": 0,
        "showProgress": Wahr,
        "Zeichensatz": "utf8mb4"
    })

Wie Sie sehen, dauert das Laden von Daten etwa 5 Minuten, während import_table weniger als die Hälfte der Zeit zum Abschließen des Datenimports benötigt, was mehr als doppelt so effizient ist (unter der Bedingung einer begrenzten Festplatten-E/A-Kapazität in der virtuellen Maschinenumgebung).

Oben sind die Details zum Importieren von MySQL Shell-Import_Table-Daten aufgeführt. Weitere Informationen zum Importieren von Import_Table-Daten finden Sie in den anderen verwandten Artikeln auf 123WORDPRESS.COM!

Das könnte Sie auch interessieren:
  • Shell-Skript zum Verbinden, Lesen, Schreiben und Bedienen einer MySQL-Datenbankinstanz
  • Shell-Skript zum regelmäßigen Sichern und Aufbewahren von MySQL-Datenbankdaten für einen bestimmten Zeitraum
  • Erstellen Sie MySQL-Datenbankkonten auf dem Server stapelweise über Shell-Skripte
  • Erfahren Sie, wie Sie mithilfe der MySQL Shell eine Verbindung zur Datenbank herstellen

<<:  Mehrere Möglichkeiten zur Implementierung der CSS-Höhenänderung mit Breitenverhältnis

>>:  Detaillierte Verwendung des Docker-Maven-Plugins

Artikel empfehlen

Detaillierte Analyse von MySQL-Ausführungsplänen

Vorwort Als wir im vorherigen Interviewprozess na...

Docker verwendet das Tool nsenter, um in den Container zu gelangen

Bei der Verwendung von Docker-Containern ist es b...

3 Tipps, die Sie beim Erlernen von JavaScript kennen müssen

Inhaltsverzeichnis 1. Der magische Erweiterungsop...

IIS7 IIS8 Reverse-Proxy-Regeln schreiben, installieren und konfigurieren

Zweck: Station A als sekundäres Verzeichnis von S...

Detaillierte Erläuterung der Verwendung der Vue3-Statusverwaltung

Inhaltsverzeichnis Hintergrund Bereitstellen / In...

10 Möglichkeiten zum Anzeigen komprimierter Dateiinhalte in Linux (Zusammenfassung)

Wenn wir den Inhalt einer archivierten oder kompr...

MySQL-Abfrageanweisungsprozess und grundlegende Konzepte der EXPLAIN-Anweisung und deren Optimierung

Die Leistung Ihrer Website oder Ihres Dienstes hä...

Vue implementiert eine Scroll-Ladetabelle

Inhaltsverzeichnis Ergebnisse erzielen Wissensres...

So aktualisieren Sie CentOS7 auf CentOS8 (detaillierte Schritte)

Dieser Artikel erläutert anhand eines konkreten B...

Docker-Grundlagen

Vorwort: Docker ist eine Open-Source-Anwendungsco...

So verwenden Sie JavaScript zum Implementieren von Sortieralgorithmen

Inhaltsverzeichnis Blasensortierung Auswahl Sorti...

Linux-Betrieb und -Wartung, grundlegendes Prozessmanagement, Echtzeitüberwachung und -steuerung

Inhaltsverzeichnis 1. Im Hintergrund laufende Job...

Vue3 erhält die aktuelle Routingadresse

Richtige Antwort Verwenden von useRouter : // Rou...

Der Unterschied zwischen Update und Select in MySQL für einzelne und mehrere Tabellen sowie Ansichten und temporäre Tabellen

1. Verwenden Sie Daten aus Tabelle A, um den Inha...

Lösen Sie das Problem der automatischen HTML-Formatierung nach dem Speichern in vscode

Die Version von vsCode wurde in den letzten Tagen...