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

Standards zum Schreiben von Codekommentaren bei der Webseitenerstellung

<br />Ich habe die in meiner Arbeit verwende...

Detaillierter Installationsprozess von mysql5.7.21 unter Win10

In diesem Artikel erfahren Sie mehr über die Inst...

Eine kurze Zusammenfassung der grundlegenden Regeln zur Leistungsoptimierung von Webseiten

Einige Optimierungsregeln für Browser-Webseiten S...

So konvertieren Sie ein JavaScript-Array in eine Baumstruktur

1. Nachfrage Das Backend stellt solche Daten bere...

Vue ruft die PC-Kamera auf, um die Fotofunktion zu realisieren

In diesem Artikelbeispiel wird der spezifische Co...

Javascript implementiert die Webversion des Flipperspiels

Das mit JavaScript-Objekten und -Methoden impleme...

Den Linux-Kernel erkunden: Die Geheimnisse von Kconfig

Erhalten Sie ein umfassendes Verständnis der Funk...

Implementierung des Nginx Intranet Standalone Reverse Proxy

Inhaltsverzeichnis 1 Nginx Installation 2 Nginx k...

Grafisches Tutorial zur Installation und Konfiguration der MySQL 5.7.21-Dekomprimierungsversion

Da ich das System häufig installiere, muss ich na...

Was sind die Verwendungszwecke von Limits in MySQL (empfohlen)

SELECT * FROM Tabellenname Limit m,n; SELECT * FR...

Verwenden von React+Redux zum Implementieren der Zählerfunktion und aufgetretene Probleme

Redux ist ein einfacher Statusmanager. Wir werden...

Lösung für leere Seite nach Vue-Verpackung

1. Lösung für das Problem, dass die Seite leer is...

JavaScript zum Erzielen digitaler Uhreffekte

In diesem Artikelbeispiel wird der spezifische Co...

Tiefgreifendes Verständnis von globalen Sperren und Tabellensperren in MySQL

Vorwort Je nach Umfang der Sperrung können Sperre...

So verwenden Sie Dockerfile zum Erstellen von Images in Docker

Erstellen des Images Früher haben wir verschieden...