MySQL => WSTAWIĆ

Składnia

INSERT [LOW_PRIORITY | OPÓŹNIONY | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (nazwa partycji, ...)] [(nazwa kolumny, ...)] {VALUES | WARTOŚĆ} ({wyrażenie | DOMYŚLNE}, ...), (...), ... [NA DUPLIKACIE AKTUALIZACJI KLUCZA nazwa_kol = wyrażenie [, nazwa_kol = wyrażenie]]]
INSERT [LOW_PRIORITY | OPÓŹNIONY | HIGH_PRIORITY] [IGNORE] [INTO] tbl_name [PARTITION (nazwa partycji, ...)] SET nazwa_kolumny = {wyrażenie | DEFAULT}, ... [ON DUPLICATE KEY UPDATE col_name = expr [, col_name = expr] ...]
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] nazwa_bloku [PARTITION (nazwa_partycji, ...)] [(nazwa_kolumny, ...)] WYBIERZ ... [NA DUPLIKATIE AKTUALIZACJI KLUCZA nazwa_kolumny = wyraż [, nazwa_kol = wyrażenie]]]
Wyrażenie wyrażenie może odnosić się do dowolnej kolumny, która została wcześniej ustawiona na liście wartości. Na przykład możesz to zrobić, ponieważ wartość dla col2 odnosi się do col1, który wcześniej został przypisany:
INSERT INTO tbl_name (col1, col2) VALUES (15, col1 * 2);
Instrukcje INSERT korzystające ze składni VALUES mogą wstawiać wiele wierszy. Aby to zrobić, dołącz wiele list wartości kolumn, każda zamknięta w nawiasach i oddzielona przecinkami. Przykład:
WSTAWIĆ DO nazwa_bloku (a, b, c) WARTOŚCI (1,2,3), (4,5,6), (7,8,9);
Lista wartości dla każdego wiersza musi być zawarta w nawiasach. Poniższa instrukcja jest niedozwolona, ponieważ liczba wartości na liście nie zgadza się z liczbą nazw kolumn:
INSERT INTO tbl_name (a, b, c) VALUES (1,2,3,4,5,6,7,8,9);
WSTAW ... WYBIERZ Składnię
INSERT [LOW_PRIORITY | HIGH_PRIORITY] [IGNORE] [INTO] nazwa_bloku [PARTITION (nazwa_partycji, ...)] [(nazwa_kolumny, ...)] WYBIERZ ... [NA DUPLIKATIE AKTUALIZACJI KLUCZA nazwa_kolumny = wyra ...]
Za pomocą INSERT ... SELECT możesz szybko wstawić wiele wierszy do tabeli z jednej lub wielu tabel. Na przykład:
INSERT INTO tbl_temp2 (fld_id) WYBIERZ tbl_temp1.fld_order_id FROM tbl_temp1 GDZIE tbl_temp1.fld_order_id> 100;

Uwagi

Podstawowa wkładka

INSERT INTO `table_name` (`field_one`, `field_two`) VALUES ('value_one', 'value_two');

W tym trywialnym przykładzie table_name to miejsce, w którym należy dodać dane, field_one i field_two to pola, dla których należy ustawić dane, a value_one i value_two to dane, które field_one field_two odpowiednio dla field_one i field_two .

Dobrą praktyką jest wylistowanie pól, do których wstawiasz dane w kodzie, tak jakby w przypadku zmiany tabeli i dodania nowych kolumn wstawianie ulegałoby uszkodzeniu, gdyby ich nie było

WSTAW, NA DUPLIKACIE KLUCZOWEJ AKTUALIZACJI

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`);

To INSERT do table_name określonych wartości, ale jeśli unikalny klucz już istnieje, to będzie zaktualizować other_field_1 mieć nową wartość.
Czasami przy aktualizacji duplikatu klucza przydaje się użycie VALUES() w celu uzyskania dostępu do oryginalnej wartości, która została przekazana do INSERT zamiast bezpośredniego ustawienia wartości. W ten sposób można ustawić różne wartości za pomocą INSERT i UPDATE . Zobacz powyższy przykład, w którym parametr other_field_1 ma wartość insert_value w INSERT lub update_value w UPDATE podczas gdy other_field_2 jest zawsze ustawiony na other_value .

Kluczowe znaczenie dla działania funkcji wstawiania przy aktualizacji duplikatu klucza (IODKU) jest schemat zawierający unikalny klucz, który zasygnalizuje duplikat starcia. Ten unikalny klucz może być kluczem podstawowym lub nie. Może to być unikalny klucz w pojedynczej kolumnie lub wielokolumnowy (klucz złożony).

Wstawianie wielu wierszy

INSERT INTO `my_table` (`field_1`, `field_2`) VALUES 
    ('data_1', 'data_2'),
    ('data_1', 'data_3'),
    ('data_4', 'data_5');

Jest to łatwy sposób na dodanie kilku wierszy jednocześnie za pomocą jednej INSERT .

Tego rodzaju wstawka „wsadowa” jest znacznie szybsza niż wstawianie wierszy jeden po drugim. Zazwyczaj wstawianie w ten sposób 100 wierszy w jednej partii wsadowej jest 10 razy szybsze niż wstawianie ich pojedynczo.

Ignorowanie istniejących wierszy

Podczas importowania dużych zestawów danych, w pewnych okolicznościach może być wskazane pominięcie wierszy, które zwykle powodują niepowodzenie zapytania z powodu ograniczeń kolumn, np. Zduplikowanych kluczy głównych. Można to zrobić za pomocą INSERT IGNORE .

Rozważ następującą przykładową bazę danych:

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  |
+----+--------+

Ważną rzeczą do zapamiętania jest to, że INSERT IGNORE również po cichu pominie inne błędy, oto, co mówią oficjalne dokumentacje Mysql:

Konwersje danych, które spowodowałyby błędy, przerywają instrukcję, jeśli IGNORE nie jest> określone. W przypadku IGNORE niepoprawne wartości są dopasowywane do najbliższych wartości i> wstawiane; generowane są ostrzeżenia, ale oświadczenie nie zostaje przerwane.

Uwaga: - Poniższa sekcja została dodana ze względu na kompletność, ale nie jest uważana za najlepszą praktykę (nie udałoby się to na przykład, gdyby do tabeli dodano inną kolumnę).

Jeśli podasz wartość odpowiedniej kolumny dla wszystkich kolumn w tabeli, możesz zignorować listę kolumn w INSERT w następujący sposób:

INSERT INTO `my_table` VALUES 
        ('data_1', 'data_2'),
        ('data_1', 'data_3'),
        ('data_4', 'data_5');

INSERT SELECT (Wstawianie danych z innej tabeli)

Jest to podstawowy sposób wstawiania danych z innej tabeli za pomocą instrukcji SELECT.

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`;

Można SELECT * FROM , ale potem tableA i tableB musi mieć dopasowanie liczby kolumn i odpowiadające typy danych.

Kolumny z AUTO_INCREMENT są traktowane jak w klauzuli INSERT with VALUES .

Ta składnia ułatwia wypełnianie (tymczasowych) tabel danymi z innych tabel, tym bardziej, gdy dane mają być filtrowane na wstawce.

INSERT z AUTO_INCREMENT + LAST_INSERT_ID ()

Gdy tabela ma AUTO_INCREMENT PRIMARY KEY AUTO_INCREMENT , zwykle nie wstawia się tej kolumny. Zamiast tego podaj wszystkie pozostałe kolumny, a następnie zapytaj, jaki był nowy identyfikator.

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, ...);

Zauważ, że LAST_INSERT_ID() jest powiązany z sesją, więc nawet jeśli wiele połączeń wstawia się do tej samej tabeli, każde z nich ma swój własny identyfikator.

Twój API klient prawdopodobnie ma alternatywny sposób uzyskania LAST_INSERT_ID() bez faktycznego wykonywania SELECT i podając wartość z powrotem do klienta zamiast pozostawienia go w @variable wewnątrz MySQL. Takie jest zwykle lepsze.

Dłuższy, bardziej szczegółowy przykład

„Normalne” użycie IODKU polega na uruchomieniu „duplikatu klucza” na podstawie jakiegoś UNIQUE klucza, a nie AUTO_INCREMENT PRIMARY KEY . Poniżej pokazano takie. Zauważ, że nie podaje id w INSERT.

Przygotuj przykłady do naśladowania:

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 |
+----+--------+------+

Przypadek IODKU przeprowadzającego „aktualizację” i LAST_INSERT_ID() pobierającego odpowiedni 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 |
+------------------+

Przypadek, w którym IODKU wykonuje „wstaw”, a LAST_INSERT_ID() pobiera nowy id :

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 |
+------------------+

Wynikowa zawartość tabeli:

SELECT * FROM iodku;
+----+--------+------+
| id | name   | misc |
+----+--------+------+
|  1 | Leslie |  123 |
|  2 | Sally  | 3333 |  -- IODKU changed this
|  3 | Dana   |  789 |  -- IODKU added this
+----+--------+------+

Utracono identyfikatory AUTO_INCREMENT

Kilka funkcji „wstawiania” może „nagrywać” identyfikatory. Oto przykład użycia InnoDB (inne silniki mogą działać inaczej):

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'
  +----+--------+

Pomyśl o tym (z grubsza) w ten sposób: Najpierw wstawka sprawdza, ile wierszy może zostać wstawionych. Następnie pobierz tyle wartości z auto_increment dla tej tabeli. Na koniec wstaw wiersze, używając identyfikatorów w razie potrzeby i wypalając wszelkie resztki.

Pozostały czas można odzyskać tylko wtedy, gdy system zostanie zamknięty i ponownie uruchomiony. Po ponownym uruchomieniu efektywnie wykonywany jest MAX(id) . Może to ponownie wykorzystywać identyfikatory, które zostały spalone lub zostały zwolnione przez DELETEs najwyższych identyfikatorów.

Zasadniczo każdy smak INSERT (w tym REPLACE , czyli DELETE + INSERT ) może nagrywać identyfikatory. W InnoDB zmienna globalna (nie sesyjna!) innodb_autoinc_lock_mode może być używana do kontrolowania niektórych rzeczy.

Kiedy „normalizujesz” długie ciągi znaków do AUTO INCREMENT id , nagrywanie może łatwo nastąpić. Może to doprowadzić do przepełnienia wielkości INT którą wybrałeś.

Modified text is an extract of the original Stack Overflow Documentation

Licencjonowany na podstawie CC BY-SA 3.0

Nie związany z Stack Overflow

MySQL
WSTAWIĆ

Szukaj…