MySQL
EINFÜGEN
Suche…
Syntax
INSERT [LOW_PRIORITY | VERZÖGERT | HIGH_PRIORITY] [IGNORE] [INTO] Tabellenname [PARTITION (Partitionsname, ...)] [(Spaltenname, ...)] {VALUES | VALUE} ({expr | DEFAULT}, ...), (...), ... [ON DUPLICATE KEY UPDATE Spaltenname = Ausdruck [, Spaltenname = Ausdruck] ...]
INSERT [LOW_PRIORITY | VERZÖGERT | HIGH_PRIORITY] [IGNORE] [INTO] Tabellenname [PARTITION (Partitionsname, ...)] SET Col_Name = {Ausdruck | DEFAULT}, ... [ON DUPLICATE KEY UPDATE Spaltenname = Ausdruck [, Spaltenname = Ausdruck] ...]
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] Tabellenname [PARTITION (Partitionsname, ...)] [(Spaltenname, ...)] SELECT ... [ON DUPLICATE KEY UPDATE Spaltenname = Ausdruck [, Spaltenname = Ausdruck] ...]
Ein Ausdruck expr kann auf jede Spalte verweisen, die zuvor in einer Werteliste festgelegt wurde. Dies ist beispielsweise möglich, weil der Wert für col2 sich auf col1 bezieht, das zuvor zugewiesen wurde:
INSERT INTO tbl_name (col1, col2) VALUES (15, col1 * 2);INSERT-Anweisungen, die die VALUES-Syntax verwenden, können mehrere Zeilen einfügen. Fügen Sie dazu mehrere Listen von Spaltenwerten hinzu, die jeweils in Klammern stehen und durch Kommas getrennt sind. Beispiel:
INSERT in tbl_name (a, b, c) WERTE (1,2,3), (4,5,6), (7,8,9);Die Werteliste für jede Zeile muss in Klammern stehen. Die folgende Anweisung ist ungültig, da die Anzahl der Werte in der Liste nicht mit der Anzahl der Spaltennamen übereinstimmt:
INSERT in tbl_name (a, b, c) WERTE (1,2,3,4,5,6,7,8,9);INSERT ... SELECT Syntax
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] Tabellenname [PARTITION (Partitionsname, ...)] [(Spaltenname, ...)] SELECT ... [ON DUPLICATE KEY UPDATE Spaltenname = Ausdruck, ...]Mit INSERT ... SELECT können Sie schnell viele Zeilen aus einer oder mehreren Tabellen in eine Tabelle einfügen. Zum Beispiel:
INSERT INTO tbl_temp2 (fld_id) SELECT tbl_temp1.fld_order_id FROM tbl_temp1 WHERE tbl_temp1.fld_order_id> 100;
Bemerkungen
Grundeinsatz
INSERT INTO `table_name` (`field_one`, `field_two`) VALUES ('value_one', 'value_two');
In diesem table_name Beispiel ist table_name wo die Daten hinzugefügt werden sollen, field_one und field_two sind Felder, für die Daten festgelegt werden sollen, und value_one und value_two sind die Daten, die gegen field_one bzw. field_two sind.
Es ist empfehlenswert, die Felder, in die Sie Daten einfügen, in Ihren Code aufzulisten. Wenn sich die Tabelle ändert und neue Spalten hinzugefügt werden, würde das Einfügen brechen, falls sie nicht vorhanden sind
INSERT, DUPLICATE KEY UPDATE
INSERT INTO `table_name`
(`index_field`, `other_field_1`, `other_field_2`)
VALUES
('index_value', 'insert_value', 'other_value')
ON DUPLICATE KEY UPDATE
`other_field_1` = 'update_value',
`other_field_2` = VALUES(`other_field_2`);
Dies wird INSERT in table_name die angegebenen Werte, aber wenn der eindeutige Schlüssel bereits vorhanden ist , wird es die Aktualisierung other_field_1 einen neuen Wert zu haben.
Beim Aktualisieren von doppelten Schlüsseln kann es manchmal nützlich sein, VALUES() zu verwenden, um auf den ursprünglichen Wert zuzugreifen, der an INSERT anstatt den Wert direkt VALUES() . Auf diese Weise können Sie mit INSERT und UPDATE verschiedene Werte einstellen. Siehe das Beispiel oben , wo other_field_1 eingestellt ist insert_value auf INSERT oder update_value auf UPDATE während other_field_2 immer gesetzt other_value .
Entscheidend für die Funktion "Insert on Duplicate Key Update" (IODKU) ist das Schema, das einen eindeutigen Schlüssel enthält, der einen doppelten Konflikt signalisiert. Dieser eindeutige Schlüssel kann ein Primärschlüssel sein oder nicht. Es kann sich dabei um einen eindeutigen Schlüssel in einer einzelnen Spalte oder um einen mehrspaltigen Schlüssel (zusammengesetzter Schlüssel) handeln.
Mehrere Zeilen einfügen
INSERT INTO `my_table` (`field_1`, `field_2`) VALUES
('data_1', 'data_2'),
('data_1', 'data_3'),
('data_4', 'data_5');
Dies ist eine einfache Möglichkeit, mit einer INSERT Anweisung mehrere Zeilen gleichzeitig hinzuzufügen.
Diese Art von 'Batch'-Insert ist viel schneller als das Einfügen von Zeilen nacheinander. Normalerweise ist das Einfügen von 100 Zeilen in eine einzelne Batch-Insertion 10-mal so schnell wie das Einfügen aller Zeilen.
Vorhandene Zeilen ignorieren
Beim Importieren großer Datensätze kann es unter bestimmten Umständen wünschenswert sein, Zeilen zu überspringen, die normalerweise dazu führen, dass die Abfrage aufgrund einer Spaltenbeschränkung fehlschlägt, z. Dies kann mit INSERT IGNORE .
Betrachten Sie die folgende Beispieldatenbank:
SELECT * FROM `people`;
--- Produces:
+----+------+
| id | name |
+----+------+
| 1 | john |
| 2 | anna |
+----+------+
INSERT IGNORE INTO `people` (`id`, `name`) VALUES
('2', 'anna'), --- Without the IGNORE keyword, this record would produce an error
('3', 'mike');
SELECT * FROM `people`;
--- Produces:
+----+--------+
| id | name |
+----+--------+
| 1 | john |
| 2 | anna |
| 3 | mike |
+----+--------+
Es ist wichtig zu wissen, dass INSERT IGNORE auch andere Fehler im Hintergrund überspringt. Hier heißt es in den offiziellen Dokumentationen von Mysql:
Datenkonvertierungen, die Fehler auslösen würden, bricht die Anweisung ab, wenn IGNORE> nicht angegeben wird. Mit IGNORE werden ungültige Werte an die nächsten Werte angepasst und> eingefügt. Es werden Warnungen ausgegeben, die Anweisung bricht jedoch nicht ab.
Hinweis: - Der folgende Abschnitt wird der Vollständigkeit halber hinzugefügt, er gilt jedoch nicht als bewährte Methode (dies würde beispielsweise fehlschlagen, wenn eine weitere Spalte in die Tabelle eingefügt wurde).
Wenn Sie den Wert der entsprechenden Spalte für alle Spalten in der Tabelle angeben, können Sie die Spaltenliste in der INSERT Anweisung wie folgt ignorieren:
INSERT INTO `my_table` VALUES
('data_1', 'data_2'),
('data_1', 'data_3'),
('data_4', 'data_5');
INSERT SELECT (Einfügen von Daten aus einer anderen Tabelle)
Dies ist die grundlegende Methode zum Einfügen von Daten aus einer anderen Tabelle mit der SELECT-Anweisung.
INSERT INTO `tableA` (`field_one`, `field_two`)
SELECT `tableB`.`field_one`, `tableB`.`field_two`
FROM `tableB`
WHERE `tableB`.clmn <> 'someValue'
ORDER BY `tableB`.`sorting_clmn`;
Sie können SELECT * FROM , aber dann tableA und tableB müssen Spaltenanzahl passende und Datentypen entsprechen.
Spalten mit AUTO_INCREMENT werden wie in der INSERT with VALUES Klausel behandelt.
Diese Syntax erleichtert das Befüllen von (temporären) Tabellen mit Daten aus anderen Tabellen. Dies gilt umso mehr, wenn die Daten im Insert gefiltert werden sollen.
INSERT mit AUTO_INCREMENT + LAST_INSERT_ID ()
Wenn eine Tabelle einen AUTO_INCREMENT PRIMARY KEY , wird normalerweise keine in diese Spalte PRIMARY KEY . Geben Sie stattdessen alle anderen Spalten an und fragen Sie nach der neuen ID.
CREATE TABLE t (
id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL,
this ...,
that ...,
PRIMARY KEY(id) );
INSERT INTO t (this, that) VALUES (..., ...);
SELECT LAST_INSERT_ID() INTO @id;
INSERT INTO another_table (..., t_id, ...) VALUES (..., @id, ...);
Beachten Sie, dass LAST_INSERT_ID() an die Sitzung gebunden ist. Selbst wenn mehrere Verbindungen in dieselbe Tabelle LAST_INSERT_ID() , LAST_INSERT_ID() jede mit ihrer eigenen ID eine eigene ID.
Ihre Client-API verfügt wahrscheinlich über eine alternative Methode, um LAST_INSERT_ID() ohne tatsächlich SELECT LAST_INSERT_ID() und den Wert an den Client zurückzugeben, anstatt ihn in einer @variable in MySQL zu @variable . Dies ist normalerweise vorzuziehen.
Länger, detaillierteres Beispiel
Die "normale" Verwendung von IODKU ist das Auslösen eines "Duplikatschlüssels" basierend auf einem UNIQUE Schlüssel, nicht dem AUTO_INCREMENT PRIMARY KEY . Das Folgende zeigt, wie z. Beachten Sie, dass es nicht die nicht liefert id in der INSERT.
Setup für die folgenden Beispiele:
CREATE TABLE iodku (
id INT AUTO_INCREMENT NOT NULL,
name VARCHAR(99) NOT NULL,
misc INT NOT NULL,
PRIMARY KEY(id),
UNIQUE(name)
) ENGINE=InnoDB;
INSERT INTO iodku (name, misc)
VALUES
('Leslie', 123),
('Sally', 456);
Query OK, 2 rows affected (0.00 sec)
Records: 2 Duplicates: 0 Warnings: 0
+----+--------+------+
| id | name | misc |
+----+--------+------+
| 1 | Leslie | 123 |
| 2 | Sally | 456 |
+----+--------+------+
Der Fall, dass IODKU ein "Update" durchführt und LAST_INSERT_ID() die relevante id LAST_INSERT_ID() :
INSERT INTO iodku (name, misc)
VALUES
('Sally', 3333) -- should update
ON DUPLICATE KEY UPDATE -- `name` will trigger "duplicate key"
id = LAST_INSERT_ID(id),
misc = VALUES(misc);
SELECT LAST_INSERT_ID(); -- picking up existing value
+------------------+
| LAST_INSERT_ID() |
+------------------+
| 2 |
+------------------+
Der Fall, in dem IODKU eine "Einfügung" durchführt und LAST_INSERT_ID() die neue id abruft:
INSERT INTO iodku (name, misc)
VALUES
('Dana', 789) -- Should insert
ON DUPLICATE KEY UPDATE
id = LAST_INSERT_ID(id),
misc = VALUES(misc);
SELECT LAST_INSERT_ID(); -- picking up new value
+------------------+
| LAST_INSERT_ID() |
+------------------+
| 3 |
+------------------+
Resultierender Tabelleninhalt:
SELECT * FROM iodku;
+----+--------+------+
| id | name | misc |
+----+--------+------+
| 1 | Leslie | 123 |
| 2 | Sally | 3333 | -- IODKU changed this
| 3 | Dana | 789 | -- IODKU added this
+----+--------+------+
Verlorene AUTO_INCREMENT-IDs
Mehrere "Einfügen" -Funktionen können IDs "brennen". Hier ein Beispiel für die Verwendung von InnoDB (andere Engines funktionieren möglicherweise anders):
CREATE TABLE Burn (
id SMALLINT UNSIGNED AUTO_INCREMENT NOT NULL,
name VARCHAR(99) NOT NULL,
PRIMARY KEY(id),
UNIQUE(name)
) ENGINE=InnoDB;
INSERT IGNORE INTO Burn (name) VALUES ('first'), ('second');
SELECT LAST_INSERT_ID(); -- 1
SELECT * FROM Burn ORDER BY id;
+----+--------+
| 1 | first |
| 2 | second |
+----+--------+
INSERT IGNORE INTO Burn (name) VALUES ('second'); -- dup 'IGNOREd', but id=3 is burned
SELECT LAST_INSERT_ID(); -- Still "1" -- can't trust in this situation
SELECT * FROM Burn ORDER BY id;
+----+--------+
| 1 | first |
| 2 | second |
+----+--------+
INSERT IGNORE INTO Burn (name) VALUES ('third');
SELECT LAST_INSERT_ID(); -- now "4"
SELECT * FROM Burn ORDER BY id; -- note that id=3 was skipped over
+----+--------+
| 1 | first |
| 2 | second |
| 4 | third | -- notice that id=3 has been 'burned'
+----+--------+
Stellen Sie sich das (ungefähr) so vor: Zuerst sieht der Insert, wie viele Zeilen eingefügt werden könnten . Dann holen Sie sich so viele Werte aus dem auto_increment für diese Tabelle. Fügen Sie zum Schluss die Zeilen ein, verwenden Sie bei Bedarf die IDs und brennen Sie die restlichen Reste.
Der Rest kann nur wiederhergestellt werden, wenn das System heruntergefahren und neu gestartet wird. Beim Neustart wird effektiv MAX(id) ausgeführt. Dies kann IDs wiederverwenden, die von DELETEs der höchsten ID (s) verbrannt oder freigegeben wurden.
REPLACE kann jede REPLACE von INSERT (einschließlich REPLACE , REPLACE DELETE + INSERT ) IDs brennen. In InnoDB kann die globale (nicht Session!) Variable innodb_autoinc_lock_mode verwendet werden, um einige der innodb_autoinc_lock_mode zu steuern.
Beim "Normalisieren" langer Zeichenfolgen in eine AUTO INCREMENT id kann es leicht zum Brennen kommen. Dies kann dazu führen, dass die Größe des von Ihnen gewählten INT überläuft.