Обновление данных в базах — один из ключевых элементов при работе в MySQL. Под обновлением подразумевается изменение значений в существующих записях таблицы. Обновление допускает различные варианты: как изменение значений полей в группе строк (в том числе и всех строк таблицы), так и корректировку значения поля отдельной строки.
Для полноценной работы как с локальными базами данных, так и с облачными базами данных cloud.timeweb.com, важно понимать синтаксис команд для обновления данных.
Ключевой командой для изменения записей в таблице базы данных в MySQL является UPDATE. Обновление происходит последовательно, от первой до последней строки, по порядку. В зависимости от типа обновления в MySQL выделяется два синтаксиса для оператора UPDATE.
В случае обновления одной таблицы синтаксис выглядит следующим образом:
UPDATE LOW_PRIORITY IGNORE table_reference
SET assignment_list
WHERE where_condition
ORDER BY ...
LIMIT row_countОбязательный параметр:
SET assignment_list — указывает, какие столбцы нужно изменить и каким образом (assignment_list — список столбцов и новых значений).
Необязательные параметры:
LOW_PRIORITY— если указан этот параметр, выполнениеUPDATEоткладывается до тех пор, пока другой пользователь не решит просмотреть данные таблицы.IGNORE— в этом сценарии выполнениеUPDATEне прерывается, даже если в процессе возникают какие-либо ошибки. Если возникают дубликаты в столбце с уникальным ключом, то такие строки не обновляются.WHERE where_condition— широко известный оператор задает условия, по которым отбираются строки для обновления (where_condition — список условий). Если параметрыWHEREне указаны, обновятся все строки таблицы.ORDER BY— если указан этот параметр, строки обновляются в заданном порядке.LIMIT row_count— ограничение на количество обновляемых строк (row_count — некое число строк). Считаются строки, которые попадают под условиеWHERE, независимо от того, изменились они или нет.
В случае обновления нескольких таблиц одновременно синтаксис будет следующим:
UPDATE LOW_PRIORITY IGNORE table_references
SET assignment_list
WHERE where_conditiontable_references — список таблиц, которые мы хотим изменить. Они изменятся таким образом, как указано в assignment_list.
При обновлении нескольких таблиц нельзя использовать параметр ORDER BY или LIMIT. Помимо этого, при обновлении нескольких таблиц нет гарантий, что они будут обновлены в указанном порядке.
Остальные параметры запроса (необязательные) — LOW_PRIORITY, IGNORE и WHERE — работают так же, как в сценарии обновления одной таблицы.
Итак, давайте рассмотрим примеры использования оператора UPDATE в MySQL.
Для начала создадим базу данных для книжного магазина. В ней будет 4 таблицы: книги, жанры, писатели и покупки.
Воспользуемся операторами CREATE TABLE и INSERT INTO, чтобы создать таблицы author, genre, book и sales.
CREATE TABLE author (
id INT PRIMARY KEY AUTO_INCREMENT,
name_author VARCHAR(50) NOT NULL
);
INSERT INTO author (name_author)
VALUES ('Leo Tolstoy'),
('Franz Kafka'),
('Nikolai Gogol'),
('William Shakespeare'),
('Homer');
CREATE TABLE genre (
id INT PRIMARY KEY AUTO_INCREMENT,
name_genre VARCHAR(30) NOT NULL
);
INSERT INTO genre (name_genre)
VALUES ('Realist novel'),
('Dystopian novel'),
('Picaresque novel'),
('Epic poetry');
CREATE TABLE book (
book_id INT PRIMARY KEY AUTO_INCREMENT,
title VARCHAR(50),
author_id INT NOT NULL,
genre_id INT,
price DECIMAL(8,2) NOT NULL,
amount INT DEFAULT 0,
FOREIGN KEY (author_id) REFERENCES author (id),
FOREIGN KEY (genre_id) REFERENCES genre (id)
);
INSERT INTO book (title, author_id, genre_id, price, amount)
VALUES ('Anna Karenina', 1,1, 650.00, 15),
('The Castle', 2,2, 570.20, 6),
('Dead Souls', 3,3, 480, 2),
('Iliad', 5,4, 518.99, 4),
('Odyssey', 5,4, 518.99, 7);
CREATE TABLE sales (
id INT PRIMARY KEY AUTO_INCREMENT,
book_id INT NOT NULL,
count INT NOT NULL,
cost DECIMAL(8,2) NOT NULL,
FOREIGN KEY (book_id) REFERENCES book (book_id)
);Получаем следующие таблицы. Таблица book:
Столбцы:
- book_id – уникальный идентификатор книги;
- title – название книги;
- author_id – идентификатор автора (внешний ключ);
- genre_id – идентификатор жанра (внешний ключ);
- price – цена книги за один экземпляр;
- amount – количество книг на складе.
Таблица genres:
Столбцы:
- id – уникальный идентификатор;
- name_genre – обозначение жанра.
Таблица author:
Столбцы:
- id – уникальный идентификатор;
- name_author – имя автора книги.
Таблица sales:
Столбцы:
- id – уникальный идентификатор операции;
- book_id – уникальный идентификатор книги из таблицы book (внешний ключ);
- count – количество купленных книг;
- cost – общая стоимость товаров.
Операции по обновлению данных
Теперь, создав образец базы данных, мы покажем выполнение различных операций по обновлению данных с использованием оператора UPDATE и других команд в MySQL.
1. Обновление всех строк
Если при использовании UPDATE вы не используете задающий условия параметр WHERE, то будут обновлены все строки в таблице. Предположим, в книжном магазине проходит акция «Всё по 500» — изменим цену всех книг на фиксированную 500 рублей:
UPDATE book
SET price=500;В результате выполнения запроса мы получим такую табличку:
Если мы попробуем присвоить значение, которое уже находится в столбце, то MySQL заметит это и не обновит его.
Если мы захотим присвоить значение NULL столбцу, при создании которого было указано NOT NULL, то запрос вернет ошибку:
Column 'name_column' cannot be nullВ то же время, если указать параметр IGNORE, то значение будет изменено на значение по умолчанию для конкретного типа: 0 для числовых, “” для символьных и «нулевое» для дат. Например, 0000 для типа данных YEAR или 0000-00-00 00:00:00 для типа DATETIME.
2. Обновление строк с условием
Изменение всех строк таблицы требуется довольно редко. Гораздо чаще нам необходимо обновить значения для какой-то конкретной записи или для нескольких. Допустим, мы хотим изменить строки по какому-то условию. Например, устроим распродажу книг, которых осталось в наличии меньше 5 штук. Для этого в MySQL с командой UPDATE используем оператор WHERE:
UPDATE book
SET price=300
WHERE amount < 5;Результат выполнения запроса:
Хорошо видно, что изменились только строки с книгами Dead Souls и Iliad, так как только они удовлетворяли прописанному в запросе условию.
3. Обновление значений с выражением
При обновлении мы можем задавать столбцу не только статичное значение, но и выражения. Предположим, в магазине проходит акция, и на книги русских писателей объявлена скидка в 15%:
UPDATE book
SET price=price * 0.85
WHERE author_id in (1,3);В таблице author имеется только два русских писателя – Leo Tolstoy и Nikolai Gogol с author_id 1 и 3 соответственно.
Результат выполнения запроса:
Обновление значений происходит в определенном порядке: слева направо. Например, следующий запрос сначала увеличит значение amount на 1, а потом удвоит его:
UPDATE book
SET amount = amount + 1, amount =amount*2;Результат выполнения запроса:
4. Обновление с DEFAULT
Также мы можем изменить значение строк на значения «по умолчанию» DEFAULT, которые задаются при создании или изменении таблицы. Для того чтобы узнать, какие значения в нашей таблице используются по умолчанию, выполним запрос:
DESC bookВ результате получим следующую структуру нашей таблицы в MySQL:
Заменим значения столбца amount на значение DEFAULT. Так как по умолчанию значение для amount было 0, мы должны получить все 0:
UPDATE book
SET amount=DEFAULT;Результат выполнения запроса соответствует ожиданиям:
5. Обновление нескольких столбцов
Используя один запрос, мы можем обновить сразу несколько столбцов. Например, изменим значения цены и количества у строк со значением book_id < 4:
UPDATE book
SET price=price*0.9,
amount = amount - 1
WHERE book_id < 4;Результат выполнения запроса:
6. Использование LIMIT
Используя параметр LIMIT, мы можем ограничить количество записей, которые должны быть обновлены. Например, обновим только первую строку:
UPDATE book
SET price=100
WHERE genre_id = 4
LIMIT 1;В таблице имеется две строки с genre_id равным 4, но, так как мы указали LIMIT 1, обновится только одна:
Также следует отметить, что LIMIT N вовсе не означает, что мы обновим N строк. В результате запроса произойдёт обработка первых N строк, подходящих под условие WHERE, независимо от того, обновились эти строки в итоге или нет.
7. Обновление нескольких таблиц
В MySQL мы можем обновить сразу несколько таблиц:
UPDATE book, author
SET amount=amount + 3,
author.name_author = '-'
WHERE book.book_id = 4 and author.id = 4;Результат запроса в таблице book:
Результат запроса в таблице authors:
8. Обновление таблиц с объединением (INNER JOIN)
Во время обновления можно также объединять таблицы при помощи команды INNER JOIN.
UPDATE book b INNER JOIN author a
ON b.author_id = a.id
SET b.title = CONCAT(b.title, ' (', a.name_author,')');
Указывать INNER необязательно, так как этот тип объединения используется по умолчанию. Запрос можно переписать следующим образом, и мы получим такой же результат:
UPDATE book, author a
SET b.title = CONCAT(b.title, ' (', a.name_author,')')
WHERE b.author_id = a.id;9. Обновление таблиц с объединением (LEFT JOIN)
Также мы можем использовать LEFT JOIN. В этом случае обязательно указывать, что мы используем именно левое объединение. Например, можно изменить на складе количество книг после их покупки. Добавим в таблицу sales две строки:
INSERT INTO sales (book_id, count, cost)
VALUES (1, 3, (SELECT price FROM book WHERE book_id = 1)*3),
(3, 1, (SELECT price FROM book WHERE book_id = 3)*1);Магазин продал 3 книги Anna Karenina и 1 книгу Dead Souls. Выполним запрос:
UPDATE book LEFT JOIN sales on book.book_id = sales.book_id
SET amount = amount - count
WHERE sales.book_id is not NULL;В итоге обновления видим, что количество книг на складе уменьшилось (для тех, которые мы продали):
Если мы попробуем не использовать LEFT JOIN, то получим ошибку «Out of range value for column ‘amount’ at row 3», т.к. amount не может быть отрицательным. Или, если добавить IGNORE, получим:
Как можно видеть в данном случае во всех строках количество уменьшилось на три книги, что нам не очень подходит.
10. Обновление с CASE, IF, IFNULL, COALESCE
При обновлении таблицы также возможно использовать условные операторы, такие как CASE, IF и т.д.
Функция CASE проверяет истинность набора условий и, в зависимости от результата, возвращает один из возможных результатов. Синтаксис при работе с UPDATE в MySQL для операторов CASE и WHEN будет следующий:
UPDATE book
SET price =
CASE genre_id
WHEN 1 THEN 100
WHEN 2 THEN 150
ELSE price
END;В данном случае, если книга имеет жанр 1 мы устанавливаем стоимость 100, если жанр 2 – стоимость 150.
Результат выполнения запроса:
Функция IF в зависимости от результата условного выражения возвращает одно из двух значений. Если книга имеет жанр 4, то мы уменьшаем ее стоимость на 200, иначе оставляем стоимость прежней:
UPDATE book
SET price = IF (genre_id = 4, price-200, price);Результат выполнения запроса:
Функция IFNULL проверяет значение выражения – если оно имеет значение NULL, то возвращается определенное значение, в противном случае возвращается само выражение. Пусть одно из значений amount оказалось NULL:
Проверим все значения в столбце amount, и если встретится NULL, заменим его на 0:
UPDATE book
SET amount = IFNULL(amount, 0);Результат выполнения запроса:
Функция COALESCE довольна похожа на IFNULL. Основная особенность заключается в том, что данная функция может принимать сразу несколько значений (два и более). Как и IFNULL, возвращает первое не равное NULL.
Для того чтобы посмотреть, как работает этот вариант, создадим таблицу следующего вида:
И выполним запрос:
UPDATE test_table
SET col4 = COALESCE(col1, col2, col3, 'нет значения');Результат выполнения запроса:
11. Обновление с сортировкой
Сортировка может помочь при обновлении поля с уникальным ключом. Если мы захотим сдвинуть наши id на 1, то, изменив первую строку, мы получим две строки, у которых id = 2, и возникнет ошибка. Но если добавить ORDER BY и начать обновлять с конца, то запрос успешно выполнится:
UPDATE book
SET book_id=book_id+1 Результат выполнения запроса:
12. Обновление на основе данных из других таблиц
Также в MySQL при работе с UPDATE в условии WHERE возможно использовать вложенные команды SELECT и FROM. В рассматриваемом примере мы сначала получаем идентификатор жанра ‘Epic poetry’, а потом на основе полученного значения отбираем строки для обновления таблицы.
UPDATE book
SET amount = 0
WHERE genre_id = (
SELECT id
FROM genre
Where name_genre = 'Epic poetry'
);
Как вариант, мы можем выбрать значения, которые нужно изменить, используя запрос:
UPDATE book
SET price = (
SELECT MIN (cost)
FROM sales)
WHERE amount < 5;Мы изменяем значения price всех книг, у которых количество на складе меньше 5, на минимальную сумму продажи.
Минимальная сумма продаж у нас 480:
В этой ситуации невозможно обновить таблицу, выбрав значения из той же таблицы в подзапросе. Но есть вариант использовать небольшую хитрость – мы можем объединить таблицу с собой:
UPDATE book AS book_1
INNER JOIN(
SELECT genre_id, MIN(amount) AS min_amount
FROM book
GROUP BY genre_id
) AS book_2 ON book_1.genre_id = book_2.genre_id
SET book_1.amount = book_2.min_amount;В данном случае подзапрос создает временную таблицу для присоединения и закрывает ее до того, как начнется выполнение UPDATE.
Подзапрос находит минимальное количество книг для каждого жанра, после чего используется для обновления столбца amount. В нашей таблице только у жанра 4 имеется больше одной строки. Значения в обеих строках должно замениться на минимальное для этого жанра – 4.
Результат выполнения запроса:
Есть еще один вариант обновления – использование SELECT FROM SELECT:
UPDATE book AS book_1
SET book_1.price = (SELECT MIN(price) AS min_price FROM (
SELECT price
FROM book) as book_2);В данном случае также создается временная таблица. Однако в этом случае присваивается только одно значение всем строкам.
Заключение
Мы постарались максимально подробно раскрыть особенности применения оператора UPDATE в MySQL. Но, конечно, практическое применение может продемонстрировать немало других интересных вариантов.
Всем привет! Сегодня в материале я расскажу о том, как происходит обновление данных в Microsoft SQL Server с использованием языка T-SQL, будет рассмотрена инструкция UPDATE. Иными словами, Вы узнаете, как изменить уже существующие данные в таблицах на SQL Server.
Ранее я уже рассказывал о том, как создаются таблицы, как они изменяются, как происходит добавление данных в эти таблицы, поэтому пришло время рассказать о том, как происходит изменение (обновление) существующих данных.
Заметка!
Упомянутые выше материалы:
- Создание таблиц в Microsoft SQL Server (CREATE TABLE);
- Изменение таблиц в Microsoft SQL Server (ALTER TABLE);
- Добавление данных в таблицы (INSERT INTO).
Заметка! Для комплексного изучения языка T-SQL рекомендую посмотреть мои видеокурсы по T-SQL, в которых используется последовательная методика обучения и рассматриваются все конструкции языка SQL и T-SQL.
Содержание
- Как обновить данные в таблицах Microsoft SQL Server?
- Описание инструкции UPDATE в T-SQL
- Упрощенный синтаксис UPDATE
- Примеры использования инструкции UPDATE
- Исходные данные для примеров
- Пример обновления одного столбца всех строк таблицы
- Пример обновления двух столбцов и только некоторых строк таблицы
- Пример использования выражений в инструкции UPDATE
- Пример обновления данных таблицы на основе данных другой таблицы
- Пример обновления данных с использованием подзапроса
- Видео-инструкция по обновлению данных в Microsoft SQL Server
Изменить данные в таблицах Microsoft SQL Server можно с помощью:
- Инструкции UPDATE;
- Конструктора SQL Server Management Studio (SSMS).
Однако в реальности обновление данных происходит только с использование инструкции UPDATE, так как использовать конструктор SSMS для каких-то массовых изменений невозможно, даже процесс обновления одного значения крайне неудобен. Поэтому я не использую конструктор, мне кажется, его мало кто использует.
Поэтому сегодня мы подробно поговорим об инструкции UPDATE.
Описание инструкции UPDATE в T-SQL
UPDATE – инструкция SQL, с помощью которой происходит изменение существующих данных в таблицах.
Важные моменты:
- Если инструкция UPDATE, т.е. обновление строк, нарушает какое-нибудь ограничение или правило, или новое значение имеет несовместимый тип данных (хотя бы для одной строки), то возникнет ошибка и все изменения отменяются, никакие строки не обновляются;
- По умолчанию инструкция UPDATE получает монопольную блокировку на целевую таблицу, которую она изменяет, это означает, что пока одна инструкция UPDATE выполняется, т.е. изменяет данные в таблице, другие инструкции не могут изменять данные в этой таблице;
- Чтобы использовать инструкцию UPDATE, нужны соответствующие разрешения на изменение данных, а также на чтение данных, если инструкция содержит условие WHERE;
- Если Вам нужно узнать количество строк, которые Вы обновили инструкцией UPDATE, например, для возврата в клиентское приложение или для любых других целей, то для этого Вы можете использовать функцию @@ROWCOUNT.
Упрощенный синтаксис UPDATE
Синтаксис UPDATE достаточно большой, и начинающим понять его сложно, поэтому, для того чтобы было проще понять логику формирования инструкции UPDATE, я приведу упрощенный синтаксис.
UPDATE Целевая таблица SET Имя столбца = Значение
FROM Таблица источник
WHERE Условие
Где
- UPDATE – инструкция обновления;
- Целевая таблица – таблица, данные в которой необходимо изменить;
- SET – команда, которая задает список обновляемых столбцов. Каждый следующий столбец указывается через запятую;
- Имя столбца – столбец, в котором расположены данные, которые необходимо изменить;
- Значение – новое значение, на которое необходимо изменить значение столбца. Можно указывать как конкретное значение, так и расчётное выражение, функцию или подзапрос. Также можно указать ключевое слово DEFAULT, что будет означать, что столбцу необходимо присвоить значение по умолчанию;
- FROM – секция, которая указывает таблицу, из которой необходимо взять новое значение столбца. Секция может содержать объединение JOIN;
- Таблица источник – таблица, в которой расположено новое значение столбца;
- WHERE – условие отбора строк, подлежащих обновлению.
Примеры использования инструкции UPDATE
Сейчас давайте рассмотрим несколько примеров SQL инструкций, которые будут обновлять данные в таблице инструкцией UPDATE.
Исходные данные для примеров
Для начала давайте определимся с исходными данными, чтобы Вы понимали, какие именно данные у нас есть, и что мы будем обновлять.
Также сразу скажу, что в качестве SQL сервера у меня выступает версия Microsoft SQL Server 2017 Express.
Следующая инструкция создает таблицы, которые мы будет использовать в примерах, и добавляет в них данные.
--Создание таблицы Goods
CREATE TABLE Goods (
ProductId INT IDENTITY(1,1) NOT NULL CONSTRAINT PK_ProductId PRIMARY KEY,
Category INT NOT NULL,
ProductName VARCHAR(100) NOT NULL,
ProductDescription VARCHAR(300) NULL,
Price MONEY NULL,
);
GO
--Создание таблицы Categories
CREATE TABLE Categories (
CategoryId INT IDENTITY(1,1) NOT NULL CONSTRAINT PK_CategoryId PRIMARY KEY,
CategoryName VARCHAR(100) NOT NULL
);
--Добавление строк в таблицу Categories
INSERT INTO Categories(CategoryName)
VALUES ('Комплектующие ПК'),
('Мобильные устройства');
GO
--Добавление строк в таблицу Goods
INSERT INTO Goods(Category, ProductName, ProductDescription, Price)
VALUES (1, 'Системный блок', 'Товар 1', 300),
(1, 'Монитор', 'Товар 2', 200),
(2, 'Смартфон', 'Товар 3', 100);
GO
--Выборка данных
SELECT * FROM Goods;
SELECT * FROM Categories;
Пример обновления одного столбца всех строк таблицы
В этом примере мы обновим значения одного столбца, при этом никаких условий мы делать не будем, т.е. обновим все строки в таблице.
Для наглядности и удобства отслеживания внесенных изменений я буду во всех примерах перед и после UPDATE посылать простой запрос SELECT, чтобы видеть, какие данные были и какие стали.
--Выборка данных SELECT * FROM Goods; --Обновление UPDATE Goods SET ProductDescription = 'Товар'; --Выборка данных SELECT * FROM Goods;
Как видите, в итоге получился очень простой запрос на обновление, мы обновили значения в столбце ProductDescription у всех строк на «Товар».
Пример обновления двух столбцов и только некоторых строк таблицы
Теперь давайте обновим два столбца, и конкретизируем строки для обновления, т.е. мы обновим не все строки в таблице, как в предыдущем примере, а только те, которые подходят под указанное нами условие (для примера Category с идентификатором 1).
--Выборка данных
SELECT * FROM Goods;
--Обновление
UPDATE Goods SET ProductDescription = 'Товар NEW',
Price = 400
WHERE Category = 1;
--Выборка данных
SELECT * FROM Goods;
В этом случае изменились значения столбцов ProductDescription и Price в строках, в которых Category = 1.
Пример использования выражений в инструкции UPDATE
Как я уже отмечал, в качестве нового значения может выступать не только какое-то конкретное значение, но и целое выражение, в котором могут использоваться как другие столбцы таблицы, так и столбец, который в данный момент обновляется.
В следующем примере в столбец ProductDescription мы добавим дополнительный текст (просто цифру 3), а значение Price мы увеличим в полтора раза. Все это мы сделаем для строки с Category = 2.
--Выборка данных
SELECT * FROM Goods;
--Обновление
UPDATE Goods SET ProductDescription = ProductDescription + ' 3',
Price = Price * 1.5
WHERE Category = 2;
--Выборка данных
SELECT * FROM Goods;
Пример обновления данных таблицы на основе данных другой таблицы
Достаточно часто требуется обновить данные одной таблицы на основе данных другой, например, просто скопировать данные. Это можно сделать за счет объединения нужных таблиц в инструкции UPDATE. При этом существует несколько способов объединения, я покажу два.
Для примера здесь мы скопируем название категорий из таблицы Categories, и вставим их в столбец ProductDescription таблицы Goods, объединять будем по идентификатору категории.
--Выборка данных SELECT * FROM Goods; --Обновление --Способ 1 UPDATE G SET ProductDescription = C.CategoryName FROM Goods G INNER JOIN Categories C ON G.Category = C.CategoryId; --Способ 2 (эквивалент) UPDATE Goods SET ProductDescription = C.CategoryName FROM Categories C WHERE Goods.Category = C.CategoryId; --Выборка данных SELECT * FROM Goods;
Пример обновления данных с использованием подзапроса
В этом примере я покажу, как можно использовать подзапрос в инструкции UPDATE. Для примера мы подсчитаем количество товаров в каждой категории и присвоим полученное значение столбцу ProductDescription.
Для того чтобы узнать количество товаров, мы будем использовать встроенную функцию COUNT, а для преобразования числа в строку — функцию CAST. Фильтровать строки в подзапросе мы будем по идентификатору категории, значение для сравнения будем получать из основного запроса.
--Выборка данных
SELECT * FROM Goods;
--Обновление
UPDATE Goods SET ProductDescription = 'Всего товаров: ' + (SELECT CAST(COUNT(*) AS VARCHAR(10))
FROM Goods G
WHERE G.Category = Goods.Category);
--Выборка данных
SELECT * FROM Goods;
Как видите, все отработало так, как мы задумали.
Видео-инструкция по обновлению данных в Microsoft SQL Server
У меня на этом все, надеюсь, материал был Вам полезен, пока!
Введение
В этой статье мы расскажем, для чего нужна команда UPDATE в MySQL и покажем как ей пользоваться на нескольких примерах.
UPDATE: что это за команда и зачем она нужна
UPDATE — это команда, которая обновляет данные в таблице. Ее общий синтаксис такой:
UPDATE [table] table_name
SET column1 = value1, column2 = value2, ...
[WHERE condition]
[ORDER BY expression [ ASC | DESC ]]
[LIMIT number_rows];
Сначала мы указываем обязательные параметры: название таблицы, названия колонок и нужные значения для обновления. Обратите внимание, что в MySQL можно использовать ключевое слово table (update table), а можно его опустить и сразу указать название таблицы.
Затем идут необязательные блоки WHERE (условие обновления), ORDER BY (сортировка) и LIMIT (ограничение количества обновляемых записей).
Создание облачной базы данных MySQL
Для начала нам понадобится сервер MySQL. На примере платформы Selectel мы покажем, как создать базу данных и подключиться к ней. Мы создадим управляемую БД — это позволит быстро создать сервер, и не заниматься его настройкой.
Если у вас уже есть развернутый сервер MySQL, можете сразу переходить к следующему разделу.
Итак, в панели управления заходим в раздел «Облачная платформа» — «Базы данных», нажимаем кнопку «Создать кластер».
На следующем экране выбираем параметры создаваемой БД. Выбираем «СУБД» — MySQL. Далее выбираем конфигурацию сервера, нам будет достаточно 2 vCPU, 4 ГБ оперативной памяти и 32 ГБ диска. Важно выбрать публичную сеть, чтобы к серверу можно было подключаться из интернета.
Ждем несколько минут, пока сервер создается. После того, как он перейдет в статус ACTIVE, можно продолжать настройку.
Нажимаем на имя кластера и переходим на вкладку «Пользователи». Тут нужно создать пользователя для доступа к БД. Запишите его имя и пароль, они понадобятся для подключения.
Затем переходим на вкладку «Базы данных», тут нужно создать БД (схему), в которой мы будем работать.
Когда БД создастся, нужно дать к ней доступ пользователю, которого мы создали на предыдущем шаге. Для этого нажмите на название БД и выберите пользователя.
Затем перейдите на вкладку «Настройки» и запишите DNS- или IP-адрес сервера, он нужен для подключения.
Все, сервер MySQL готов к работе, подключитесь к нему. В рамках этой статьи мы ограничимся обычным консольным клиентом mysql. Но вы можете использовать любые другие способы, которые позволяют писать SQL-команды. Например, в нашем блоге есть статья про инструмент MySQL Workbench.
Структура таблиц
Мы будем рассматривать работу с командой UPDATE на примере очень простой схемы БД. Представим, что мы — сеть магазинов бытовой техники. У нас есть 3 таблицы:
- categories: таблица категорий товаров. В ней хранятся только идентификаторы и названия категорий.
+----+------------------+
| id | name |
+----+------------------+
| 1 | Ноутбуки |
| 2 | Планшеты |
| 3 | Телефоны |
+----+------------------+
- stores: таблица магазинов. В ней хранятся идентификаторы, названия магазинов, город и адрес.
+----+------------------+---------------------+----------------------+
| id | name | city | address |
+----+------------------+---------------------+----------------------+
| 1 | Магазин 1 | Санкт-Петербург | Цветочная 63 |
| 2 | Магазин 2 | Санкт-Петербург | Советская 20 |
| 3 | Магазин 3 | Москва | Берзарина 42 |
| 4 | Магазин 4 | Москва | Авиамоторная 96 |
+----+------------------+---------------------+----------------------+
- products: таблица товаров. В ней хранятся идентификаторы, названия товаров, ссылки на категорию товара и магазин, цена товара и его количество.
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 50000 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 79000 | 2 |
| 3 | Планшет 1 | 2 | 2 | 8000 | 5 |
| 4 | Планшет 2 | 2 | 4 | 12000 | 3 |
| 5 | Телефон 1 | 3 | 1 | 18000 | 5 |
| 6 | Телефон 2 | 3 | 2 | 25000 | 1 |
| 7 | Телефон 3 | 3 | 3 | 78000 | 1 |
+----+------------------+-------------+----------+-------+----------+
Мы не будем показывать, как создать таблицы, это выходит за рамки статьи. Мы писали отдельную статью про работу с таблицами — почитайте, если вы еще не умеете создавать их.
Пример 1: обновление одной строки
Допустим, мы хотим изменить стоимость одного конкретного товара. Для этого указываем имя MySQL таблицы (update products), название обновляемого поля и значение (set price = 50500), а также условие, какую именно стоку нужно обновить (where id = 1):
UPDATE products
SET price = 50500
WHERE id = 1;
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 50500 | 1 |
+----+------------------+-------------+----------+-------+----------+
Теперь покажем, как обновить сразу несколько полей в одной строке. Например, у товара одновременно изменилась стоимость и количество. Вместо того, чтобы писать два отдельных запроса, мы укажем сразу оба изменяемых поля и их значения:
UPDATE products
SET price = 78500, quantity = 3
WHERE id = 2;
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 2 | Ноутбук 2 | 1 | 3 | 78500 | 3 |
+----+------------------+-------------+----------+-------+----------+
Пример 2: обновление всех строк в таблице
Также можно обновить сразу несколько строк в одной таблице, или даже все. Например, мы хотим выровнять количество всех товаров во всех магазинах, и установить его равным трем. Для этого нам нужно просто опустить блок WHERE, и тогда оператор UPDATE применит все, что указано в блоке SET сразу ко всем строкам в таблице:
UPDATE products
SET quantity = 3;
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 50500 | 3 |
| 2 | Ноутбук 2 | 1 | 3 | 78500 | 3 |
| 3 | Планшет 1 | 2 | 2 | 8000 | 3 |
| 4 | Планшет 2 | 2 | 4 | 12000 | 3 |
| 5 | Телефон 1 | 3 | 1 | 18000 | 3 |
| 6 | Телефон 2 | 3 | 2 | 25000 | 3 |
| 7 | Телефон 3 | 3 | 3 | 78000 | 3 |
+----+------------------+-------------+----------+-------+----------+
Пример 3: обновление с выражением
Вместо конкретного значения можно использовать выражение, на основании которого будет вычисляться значение. Например, в магазинах проходит акция, и нужно снизить цены всех ноутбуков на 10%. Рассчитывать значение вручную для каждого товара неудобно, поэтому мы используем выражение. Укажем, что цену нужно умножить на 0.9, то есть сделать ее равной 90% от начальной:
UPDATE products
SET price = (price * 0.9);
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 45450 | 3 |
| 2 | Ноутбук 2 | 1 | 3 | 70650 | 3 |
| 3 | Планшет 1 | 2 | 2 | 7200 | 3 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 3 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 3 |
| 6 | Телефон 2 | 3 | 2 | 22500 | 3 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 3 |
+----+------------------+-------------+----------+-------+----------+
Пример 4: обновление на основе данных из других таблиц
В условии WHERE можно использовать данные, полученные из других таблиц. Расширим предыдущий пример с выражением. В этот раз акция проходит только в магазине с названием «Магазин 2». Для этого нужно в условии WHERE указать идентификатор магазина, для которого нужно обновить цены. Но вместо того, чтобы искать в таблице идентификатор и потом подставлять его в SQL-запрос, мы можем указать название, а идентификатор подставится сам.
Мы используем вложенный оператор SELECT, который сначала вернет идентификатор нужного нам магазина, а затем подставит его в блок WHERE:
UPDATE products
SET price = (price * 0.9)
WHERE store_id = (
SELECT id
FROM stores
WHERE name = 'Магазин 2'
);
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 45450 | 3 |
| 2 | Ноутбук 2 | 1 | 3 | 70650 | 3 |
| 3 | Планшет 1 | 2 | 2 | 6480 | 3 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 3 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 3 |
| 6 | Телефон 2 | 3 | 2 | 20250 | 3 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 3 |
+----+------------------+-------------+----------+-------+----------+
То же самое можно сделать с помощью оператора JOIN:
UPDATE products
JOIN stores ON stores.id = store_id
SET price = (price * 0.9)
where stores.name = 'Магазин 2';
Пример 5: ключевое слово DEFAULT
В блоке SET вместо указания конкретного значения можно использовать ключевое слово DEFAULT, которое установит для этого столбца значение по умолчанию. Если для столбца не указано значение по умолчанию, тогда значение будет равно NULL.
В нашей таблице products у поля quantity есть значение по умолчанию, оно равно 1. Поэтому когда мы выполним следующую команду, количество всех товаров станет равным единице:
UPDATE products
SET quantity = DEFAULT;
Результат:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 45450 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 70650 | 1 |
| 3 | Планшет 1 | 2 | 2 | 6480 | 1 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 1 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 1 |
| 6 | Телефон 2 | 3 | 2 | 20250 | 1 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 1 |
+----+------------------+-------------+----------+-------+----------+
Пример 6: обновление значений в нескольких таблицах
Команда UPDATE может обновить значения сразу в нескольких таблицах за один раз. Допустим, мы хотим обновить адрес одного из магазинов, и тут же обновить количество товара в нем:
UPDATE stores, products
SET stores.address = 'Пятницкая 23', products.quantity = 3
WHERE stores.id = 4
and products.store_id = 4;
Результат, таблица stores:
+----+------------------+---------------------+----------------------+
| id | name | city | address |
+----+------------------+---------------------+----------------------+
| 1 | Магазин 1 | Санкт-Петербург | Цветочная 63 |
| 2 | Магазин 2 | Санкт-Петербург | Советская 20 |
| 3 | Магазин 3 | Москва | Берзарина 42 |
| 4 | Магазин 4 | Москва | Пятницкая 23 |
+----+------------------+---------------------+----------------------+
Результат, таблица products:
+----+------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 | 1 | 1 | 45450 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 70650 | 1 |
| 3 | Планшет 1 | 2 | 2 | 6480 | 1 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 3 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 1 |
| 6 | Телефон 2 | 3 | 2 | 20250 | 1 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 1 |
+----+------------------+-------------+----------+-------+----------+
Пример 7: ограничение количества обновляемых строк
Ключевое слово LIMIT позволяет ограничить количество обновляемых строк, не смотря на то, сколько на самом деле строк подошло под условие WHERE. Например, этот запрос дописать к названиям всех товаров примечание «(2020 год)». Но так как мы указали ограничение LIMIT 1, то обновится только одна строка:
UPDATE products
SET name = CONCAT(name, ' (2020 год)')
LIMIT 1;
Результат:
+----+-----------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+-----------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 (2020 год) | 1 | 1 | 45450 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 70650 | 1 |
| 3 | Планшет 1 | 2 | 2 | 6480 | 1 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 3 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 1 |
| 6 | Телефон 2 | 3 | 2 | 20250 | 1 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 1 |
+----+-----------------------+-------------+----------+-------+----------+
Пример 8: условные операторы IF и CASE
Иногда значение в блоке SET может быть не явным, а зависеть от какого-либо условия. Например, мы хотим уменьшить цены на все ноутбуки на 100р. Мы уже знаем, как это можно сделать с помощью условия WHERE. А теперь покажем, как то же самое можно сделать с помощью условного оператора IF:
UPDATE products
SET price = IF(category_id=1, price-100, price);
Результат:
+----+-----------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+-----------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 (2020 год) | 1 | 1 | 45350 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 70550 | 1 |
| 3 | Планшет 1 | 2 | 2 | 6480 | 1 |
| 4 | Планшет 2 | 2 | 4 | 10800 | 3 |
| 5 | Телефон 1 | 3 | 1 | 16200 | 1 |
| 6 | Телефон 2 | 3 | 2 | 20250 | 1 |
| 7 | Телефон 3 | 3 | 3 | 70200 | 1 |
+----+-----------------------+-------------+----------+-------+----------+
Усложним пример. Теперь нам нужно уменьшить цены на ноутбуки на 100р, на планшеты поднять на 100р, а телефоны — уменьшить на 5%. Для этого лучше подойдет другой условный оператор — CASE. В нем мы можем перечислить сразу несколько условий:
UPDATE products SET price = CASE
WHEN category_id = 1 THEN price-100
WHEN category_id = 2 THEN price+100
WHEN category_id = 3 THEN price*0.95
END;
Результат:
+----+-----------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+-----------------------+-------------+----------+-------+----------+
| 1 | Ноутбук 1 (2020 год) | 1 | 1 | 45250 | 1 |
| 2 | Ноутбук 2 | 1 | 3 | 70450 | 1 |
| 3 | Планшет 1 | 2 | 2 | 6580 | 1 |
| 4 | Планшет 2 | 2 | 4 | 10900 | 3 |
| 5 | Телефон 1 | 3 | 1 | 15390 | 1 |
| 6 | Телефон 2 | 3 | 2 | 19238 | 1 |
| 7 | Телефон 3 | 3 | 3 | 66690 | 1 |
+----+-----------------------+-------------+----------+-------+----------+
Пример 9: сортировка ORDER BY
В MySQL сортировка ORDER BY обычно используется в операторе SELECT, но также ее можно использовать и в UPDATE. В этом случае записи будут обновляться в указанном порядке. Вот одна из ситуаций, когда это может пригодиться.
Допустим, мы хотим обновить идентификаторы всех товаров — увеличить на единицу. Для этого мы напишем такую команду:
UPDATE products
SET id = (id+1);
Но СУБД вернет ошибку: Duplicate entry ’2′ for key ’products.PRIMARY’. Так происходит потому, что операция UPDATE начинает обрабатывать строки последовательно, начиная с первой. И получается, что она пытается обновить идентификатор в первой строке с 1 на 2. Но сейчас в БД уже есть запись с ключом = 2, поэтому появляется ошибка. Чтобы этого избежать, мы можем использовать ORDER BY и начать обновлять таблицу с конца:
UPDATE products
SET id = (id+1)
ORDER BY id DESC;
Результат:
+----+-----------------------+-------------+----------+-------+----------+
| id | name | category_id | store_id | price | quantity |
+----+-----------------------+-------------+----------+-------+----------+
| 2 | Ноутбук 1 (2020 год) | 1 | 1 | 45250 | 1 |
| 3 | Ноутбук 2 | 1 | 3 | 70450 | 1 |
| 4 | Планшет 1 | 2 | 2 | 6580 | 1 |
| 5 | Планшет 2 | 2 | 4 | 10900 | 3 |
| 6 | Телефон 1 | 3 | 1 | 15390 | 1 |
| 7 | Телефон 2 | 3 | 2 | 19238 | 1 |
| 8 | Телефон 3 | 3 | 3 | 66690 | 1 |
+----+-----------------------+-------------+----------+-------+----------+
Заключение
Мы познакомились с командой UPDATE, рассмотрели различные варианты ее использования и подкрепили знания на примерах. Вы узнали, как с помощью SQL запроса обновить данные в таблице. Теперь вы сможете на основе этих примеров писать команды для своей структуры таблиц.
Под обновлением данных в БД подразумевается изменение значений в существующих записях таблицы. При этом возможно как изменение значений полей в группе строк (даже всех строк таблицы), так и правка значения поля отдельной строки.
В SQL, изменить запись в таблице БД можно с помощью команды UPDATE. В самом минимальном виде команда обновления данных выглядит следующим образом:
UPDATE таблица SET поле = значениеЗдесь, UPDATE – команда указывающая, что запрос на обновление данных;
таблица – название таблицы, в которой будет проводиться изменения;
SET – команда, после которой через запятую указываются поля с назначаемыми им значениями;
поле – поле таблицы, в которое будет внесено изменение;
значение – новое значение, которое будет внесено в поле.
Например, если необходимо задать полю во всех строках таблицы значение равное нулю, можно выполнить такой запрос:
UPDATE goods SET price = 0В этом случае, поле price абсолютно во всех имеющиеся строках таблицы примет значение 0.
Изменение одного значения
Изменение значения всех полей в таблице необходимо крайне редко. Чаще всего необходимо поменять значение какой-то конкретной записи. Для этого в завершении строки с командой UPDATE будет добавлена директива WHERE, в которой указывается условие, определяющее с какой именно строкой нужно выполнить операцию обновления.
Имеется таблица:
| num (номер товара) |
title (название) |
price (цена) |
| 1 | Чайник | 300 |
| 2 | Чашка | 100 |
| 3 | Ложка | 25 |
| 4 | Тарелка | 100 |
Для примера, нужно обновить стоимость товара с известным нам его значением num. Для этого, выполним следующий запрос:
UPDATE goods SET price = 150 WHERE num = 2Теперь, перед операцией изменения полей, будет выбрана строка, удовлетворяющая условию num = 2. Такая строка в таблице одна. В этой стоке цена и будет изменена на значение 150. В результате получим таблицу с измененной ценой товара.
Внесение изменений в несколько строк с условием отбора
Если вспомнить все многообразие условий в запросе, можно представить себе насколько разнообразными могут быть выборки. Поэтому и запросы на обновления могут выполняться либо с одной строкой, либо с группой строк, либо со всеми строками таблицы. Все зависит от стоящей перед вами задачи, а так же с какими строками таблицы нужно выполнять операции обновления.
Например, мы хотим уменьшить в два раза цену всех товаров, которые сейчас стоят от 100 и более. Запрос:
UPDATE goods SET price = price / 2 WHERE price >= 100Условие WHERE здесь содержит правило, по которому будут выбраны только товары с ценой равной или более 100, а те товары, цена у которых ниже 100, затронуты запросом не будут.
price = price / 2 – формула, по которой будет вычисляться новая цена товаров. Новая цена будет записана равной старой цене поделенной на два.
В результате выполнения такого запроса получим таблицу с измененными записями:
| num (номер товара) |
title (название) |
price (цена) |
| 1 | Чайник | 150 |
| 2 | Чашка | 50 |
| 3 | Ложка | 25 |
| 4 | Тарелка | 50 |
Обновление значений в нескольких полях строки
При необходимости обновлять сразу несколько полей, все поля с их значениями указываются после директивы SET через запятую. Например, нужно изменить название и цену товара с кодом 2 на «утюг», стоимостью 300:
UPDATE goods SET title = "утюг", price = 300 WHERE num = 2Такой запрос каждому соответствующему полю в строке назначит его значение. А условие укажет, в какой именно строке будут выполнены изменения.
Выше приведены основные виды операций обновления. На их основе формируется запросы для решения большинства задач изменения данных в разработке с применением SQL.
В этом учебном материале вы узнаете, как использовать SQL оператор UPDATE с синтаксисом и примерами.
Описание
SQL оператор UPDATE используется для обновления существующих записей в таблицах.
Синтаксис
Синтаксис для оператора UPDATE при обновлении таблицы в SQL.
UPDATE table
SET column1 = expression1,
column2 = expression2,
…
[WHERE conditions];
Или
Синтаксис SQL оператора UPDATE при обновлении таблицы данными из другой таблицы:
UPDATE table1
SET column1 = (SELECT expression1
FROM table2
WHERE conditions)
[WHERE conditions];
Или
Синтаксис SQL оператора UPDATE при обновлении нескольких таблиц (не разрешен в Oracle):
UPDATE table1, table2, …
SET column1 = expression1,
column2 = expression2,
…
WHERE table1.column = table2.column
[AND conditions];
Параметры или аргументы
- column1, column2
- Столбцы, которые вы хотите обновить
- expression1, expression2
- Это новые значения, назначаемые column1, column2. Поэтому column1 будет присвоено значение expression1, а column2 будет присвоено значение expression2 и т.д.
- WHERE conditions
- Необязательный. Условия, которые должны быть выполнены, чтобы выполнить обновление. Если никаких условий не предусмотрено, то все записи в таблице будут обновлены
Пример — обновить один столбец
Давайте рассмотрим пример, показывающий, как использовать SQL оператор UPDATE для обновления одного столбца в таблице.
В этом примере UPDATE у нас есть таблица customers со следующими данными:
| customer_id | first_name | last_name | favorite_website |
|---|---|---|---|
| 4000 | Justin | Bieber | google.com |
| 5000 | Selena | Gomez | bing.com |
| 6000 | Mila | Kunis | yahoo.com |
| 7000 | Tom | Cruise | oracle.com |
| 8000 | Johnny | Depp | NULL |
| 9000 | Russell | Crowe | google.com |
Теперь давайте продемонстрируем, как работает оператор UPDATE, обновив один столбец в таблице customers. Введите следующую команду UPDATE.
|
UPDATE customers SET first_name = ‘Joseph’ WHERE customer_id = 8000; |
Будет обновлена 1 запись. Выберите данные из таблицы customers еще раз:
Вот результаты, которые вы должны получить.
В этом примере UPDATE для поля first_name установлено значение ‘Joseph’ в таблице customers, где customer_id равно 8000.
Пример — обновить несколько столбцов
Давайте рассмотрим пример UPDATE, который показывает, как обновить более одного столбца в таблице.
Подсказка:. Когда вы обновляете несколько столбцов в выражении UPDATE, вам нужно разделить запятыми пары столбец / значение в предложении SET.
В этом примере UPDATE у нас есть таблица suppliers со следующими данными:
| customer_id | first_name | last_name | favorite_website |
|---|---|---|---|
| 4000 | Justin | Bieber | google.com |
| 5000 | Selena | Gomez | bing.com |
| 6000 | Mila | Kunis | yahoo.com |
| 7000 | Tom | Cruise | oracle.com |
| 8000 | Joseph | Depp | NULL |
| 9000 | Russell | Crowe | google.com |
| supplier_id | supplier_name | city | state |
|---|---|---|---|
| 100 | Yandex | Moscow | Russian |
| 200 | Lansing | Michigan | |
| 300 | Oracle | Redwood City | California |
| 400 | Bing | Redmond | Washington |
| 500 | Yahoo | Sunnyvale | Washington |
| 600 | DuckDuckGo | Paoli | Pennsylvania |
| 700 | Qwant | Paris | France |
| 800 | Menlo Park | California | |
| 900 | Electronic Arts | San Francisco | California |
Теперь давайте продемонстрируем, как использовать оператор UPDATE для обновления более одного значения столбца одновременно. Введите следующую команду UPDATE.
|
UPDATE suppliers SET supplier_id = 150, supplier_name = ‘Apple’, city = ‘Cupertino’ state = ‘California’ WHERE supplier_name = ‘Google’; |
Будет обновлена 1 запись. Снова выберите данные из таблицы suppliers:
Вот результаты, которые вы должны получить.
| supplier_id | supplier_name | city | state |
|---|---|---|---|
| 100 | Yandex | Moscow | Russian |
| 150 | Apple | Cupertino | California |
| 300 | Oracle | Redwood City | California |
| 400 | Bing | Redmond | Washington |
| 500 | Yahoo | Sunnyvale | Washington |
| 600 | DuckDuckGo | Paoli | Pennsylvania |
| 700 | Qwant | Paris | France |
| 800 | Menlo Park | California | |
| 900 | Electronic Arts | San Francisco | California |
В этом примере UPDATE будет обновлено значение supplier_id до 150, для supplier_name — ‘Apple’, для city — ‘Cupertino’, а для state — ‘California’, где supplier_name это «Google».
Пример — обновление таблицы данными из другой таблицы
Давайте рассмотрим пример UPDATE, который показывает, как обновить таблицу данными из другой таблицы.
В этом примере UPDATE у нас есть таблица products со следующими данными:
| product_id | product_name | category_id |
|---|---|---|
| 1 | Pear | 50 |
| 2 | Banana | 50 |
| 3 | Orange | 50 |
| 4 | Apple | 50 |
| 5 | Bread | 75 |
| 6 | Sliced Ham | 25 |
| 7 | Kleenex | NULL |
И таблица summary_data со следующими данными:
| product_id | current_category |
|---|---|
| 1 | 10 |
| 2 | 10 |
| 3 | 10 |
| 4 | 10 |
| 5 | 10 |
| 8 | 10 |
Теперь давайте обновим таблицу summary_data значениями из таблицы products. Введите следующую команду UPDATE:
|
UPDATE summary_data SET current_category = (SELECT category_id FROM products WHERE products.product_id = summary_data.product_id) WHERE EXISTS (SELECT category_id FROM products WHERE products.product_id = summary_data.product_id); |
Будет обновлено 5 записей. Снова выберите данные из таблицы summary_data:
|
SELECT * FROM summary_data; |
Вот результаты, которые вы должны получить.
| product_id | current_category |
|---|---|
| 1 | 50 |
| 2 | 50 |
| 3 | 50 |
| 4 | 50 |
| 5 | 75 |
| 8 | 10 |
В этом примере будет обновлено поле current_category в таблице summary_data с помощью category_id из таблицы products, где значения product_id совпадают. Первые 5 записей в таблице summary_data были обновлены.
Подсказка: обратите внимание, что наш оператор UPDATE включил условие EXISTS в предложение WHERE, чтобы убедиться, что в таблице products и summary_data совпадает product_id, прежде чем обновлять запись.
Если бы мы не включили условие EXISTS, запрос UPDATE обновил бы поле current_category до NULL в 6-й строке таблицы summary_data (поскольку таблица products не имеет записи, где product_id = 8).