Виды связей в базах данных
MySQL — это реляционная база данных. Это означает, что данные в базе могут быть распределены в нескольких таблицах, и связаны друг с другом с помощью отношений (relation). Отсюда и название — реляционные.
Связи между таблицами происходят с помощью ключей. К примеру, в созданной нами ранее таблице пользователей есть первичный ключ — поле id. Если мы захотим сделать таблицу со статьями и хранить в ней авторов этих статей, то мы можем добавить новый столбец author_id и хранить в нём id пользователей из таблицы users.
Это был лишь один из примеров. Всего же типов подобных связей может быть 3:
- один-к-одному;
- один-ко-многим;
- многие-ко-многим.
Давайте же рассмотрим пример каждой из этих связей.
- PHP программист От 150000₽
- PHP/Golang developer До 2500$
- Стажер \ Джун PHP До 20000₽
- Senior / Middle PHP Developer | Laravel 180000₽ — 250000₽
- Разработчик PHP (middle+) 110000₽ — 130000₽
Один-к-одному
При связи один-к-одному каждой записи таблицы соответствует только одна запись в другой таблице.
Давайте заведем ещё одну таблицу, в которой будет храниться профиль пользователя. В нём можно будет указать информацию о себе и ссылку на профиль в VKontakte.
CREATE TABLE `profiles` ( `id` INT NOT NULL , `about` TEXT NULL , `vk_link` VARCHAR(255) NULL , PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Добавим для каждого пользователя профиль:
- Привет, мир!
- Развернуть строку
- Чётные числа
- Числа Фибоначчи
INSERT INTO profiles (id, about, vk_link) SELECT id, "Стрессоустойчивость, коммуникабельность", CONCAT("https://vk.com/id", id) FROM users;
Посмотрим на получившиеся профили:
SELECT * FROM profiles;
Теперь каждой записи из таблицы users соответствует только одна запись из таблицы users_profiles и наоборот.
INNER JOIN
Прежде чем идти дальше и рассматривать другие типы связей, стоит изучить ещё один оператор SQL — INNER JOIN. Он используется для объединения строк из двух и более таблиц, основываясь на отношениях между ними. Для запроса используется следующий синтаксис:
SELECT столбцы FROM таблица1 INNER JOIN таблица2 ON условие_для_связи
Чтобы получить всех пользователей вместе с их профилями нам нужно выполнить следующий запрос:
SELECT * FROM users INNER JOIN profiles ON users.id = profiles.id;
Каждая строка из левой таблицы, сопоставляется с каждой строкой из правой таблицы, после этого проверяется условие.
Если мы хотим выбрать только некоторые столбцы, то после оператора SELECT нужно перед именем поля явно указать название таблицы, из которой оно берется:
SELECT users.id, users.name, profiles.vk_link FROM users INNER JOIN profiles ON users.id = profiles.id;
Алиасы
Согласитесь, в прошлом примере пришлось довольно много букв написать. Чтобы этого избежать, в запросах можно использовать алиасы для имён таблиц. Для этого после имени таблицы можно написать AS alias. Давайте для таблицы users зададим алиас — u, а для таблицы profiles — p. Эти алиасы теперь можно использовать в любой части запроса:
SELECT u.id, u.name, p.vk_link FROM users AS u INNER JOIN profiles as p ON u.id = p.id;
Заметьте, запрос сократился. Писать запрос с использованием алиаса быстрее.
Как уже говорилось выше, алиас можно использовать в любой части запроса, в том числе и в условии WHERE:
SELECT u.id, u.name, p.vk_link FROM users AS u INNER JOIN profiles as p ON u.id = p.id WHERE u.id=2;
Один-ко-многим
При такой связи одной записи в одной таблице соответствует несколько записей в другой. В начале этого урока мы рассмотрели как раз такой пример, когда говорили о добавлении в таблицу с новостями поля author_id. Таким образом, у каждой статьи есть один автор. В то же время у одного автора может быть несколько статей.
Давайте создадим таблицу для статей. Пусть в ней будет идентификатор статьи, её название, текст, и идентификатор автора.
CREATE TABLE `my_db`.`articles` ( `id` INT NOT NULL AUTO_INCREMENT , `author_id` INT NOT NULL , `name` TEXT NOT NULL , `text` TEXT NOT NULL , PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Добавим несколько статей:
INSERT INTO `articles`(`author_id`, `name`, `text`) VALUES (1, "Пингвины научились летать", "Шокирующая новость поразила общественность!"); INSERT INTO `articles`(`author_id`, `name`, `text`) VALUES (1, "В городе N обнаружен зомби-вирус", "Шокирующая новость поразила общественность!"); INSERT INTO `articles`(`author_id`, `name`, `text`) VALUES (2, "Котики снижают уровень стресса", "Успокаивающая новость расслабила общественность");
Запросим теперь эти записи, чтобы убедиться, что всё ок
SELECT * FROM articles;
Давайте теперь выведем имена статей вместе с авторами. Для этого снова воспользуемся оператором INNER JOIN.
SELECT a.name, u.name FROM articles AS a INNER JOIN users AS u ON a.author_id=u.id;
Как видим, у Ивана две статьи, и ещё одна у Ольги.
Если бы мы захотели на странице со статьей выводить рядом с автором краткую информацию о нем, нам нужно было бы сделать ещё один JOIN на табличку profiles.
SELECT a.name, u.name, p.about FROM articles AS a INNER JOIN users AS u ON a.author_id=u.id INNER JOIN profiles AS p ON u.id=p.id;
LEFT JOIN
Помимо INNER JOIN, есть ещё несколько операторов класса JOIN. Один из самых частоиспользуемых — LEFT JOIN. Он позволяет сделать запрос к двум таблицам, между которыми есть связь, и при этом для одной из таблиц вернуть записи, даже если они не соответствуют записям в другой таблице.
Как например, если бы мы хотели вывести не только пользователей, у которых есть статьи, но и тех, кто «халтурит» 🙂
Давайте для начала сделаем запрос с использованием INNER JOIN, который выведет пользователей и написанные ими статьи:
SELECT u.id, u.name, a.name FROM users AS u INNER JOIN articles AS a ON u.id=a.author_id;
Теперь заменим INNER JOIN на LEFT JOIN:
SELECT u.id, u.name, a.name FROM users AS u LEFT JOIN articles AS a ON u.id=a.author_id;
Видите, вывелись записи из левой таблицы (users), которым не соответствует при этом ни одна запись из правой таблицы (articles).
Многие-ко-многим
Такая связь возникает, когда множество строк одной таблицы соответствуют множеству строк другой таблицы. Чтобы связать их между собой, нужно создать третью таблицу, создав с каждой из первых двух связь один-ко-многим.
В качестве примера такой связи можно привести рубрики статей. Каждая статья может иметь несколько рубрик. И одновременно с этим, каждая рубрика может содержать в себе несколько статей. Давайте добавим таблицу для рубрик.
CREATE TABLE `categories` ( `id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR(255) NOT NULL , PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
И сразу добавим в неё несколько рубрик.
INSERT INTO `categories`(`name`) VALUES ("Хорошие новости"); INSERT INTO `categories`(`name`) VALUES ("Плохие новости"); INSERT INTO `categories`(`name`) VALUES ("Новости о животных");
Проверим, что они добавились.
SELECT * FROM categories;
Теперь нам нужно добавить ещё одну таблицу, в которой будут храниться связи между article.id и category.id. Создаём:
CREATE TABLE `articles_categories` ( `article_id` INT NOT NULL , `category_id` INT NOT NULL , PRIMARY KEY (`article_id`, `category_id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
Обратите внимание на составной первичный ключ. Здесь нам требуется, чтобы именно пара (id_статьи — id_рубрики) была уникальной. А сами по себе значения в отдельных колонок могут повторяться.
И давайте добавим нашу новость о котиках в категории:
- Новости о животных
- Хорошие новости
INSERT INTO `articles_categories`(`article_id`, `category_id`) VALUES (3, 1); INSERT INTO `articles_categories`(`article_id`, `category_id`) VALUES (3, 3);
Добавим также новость о вирусе в «Плохие новости».
INSERT INTO `articles_categories`(`article_id`, `category_id`) VALUES (2, 2);
а новость про пингвинах в «Новости о животных».
INSERT INTO `articles_categories`(`article_id`, `category_id`) VALUES (1, 3);
Посмотрим что у нас получилось:
SELECT * FROM articles_categories;
Теперь давайте выведем рубрики новости о котиках:
SELECT c.name FROM categories AS c INNER JOIN articles_categories AS ac ON ac.category_id=c.id INNER JOIN articles AS a ON a.id=ac.article_id WHERE a.name="Котики снижают уровень стресса";
Таким образом реализуется связь многие-ко-многим.
Связь таблиц в MySQL через PHP: подробное руководство
Узнайте, как связать таблицы в MySQL через PHP и использовать эти связи для получения связанных данных. Эта статья дает подробное объяснение о том, как правильно настроить отношения между таблицами, создать внешние ключи и использовать JOIN-запросы для получения данных из связанных таблиц.
MySQL — одна из самых популярных систем управления базами данных, которая широко применяется в различных веб-приложениях. Вместе с языком программирования PHP она позволяет создавать сложные и функциональные веб-сайты. Одним из важных аспектов работы с базами данных является связь таблиц между собой.
Связи между таблицами позволяют устанавливать взаимосвязь между данными в разных таблицах. Это позволяет эффективно организовывать и структурировать информацию в базе данных. В MySQL существует несколько типов связей: один к одному, один ко многим и многие ко многим.
Однако, для работы с связями необходимо знать основные принципы и способы их установки и использования в PHP. Один из способов — использование внешних ключей, которые позволяют связывать две таблицы по определенному полю. Это позволяет автоматически обновлять и удалять связанные записи при изменении или удалении записи в родительской таблице. Еще один способ — использование JOIN-запросов, которые позволяют объединять данные из нескольких таблиц в один результат.
В данной статье мы рассмотрим основные принципы установки связей между таблицами в MySQL через PHP, а также различные способы их использования. Мы рассмотрим примеры кода и практические советы, которые помогут вам правильно организовать и использовать связи между таблицами в ваших веб-приложениях.
Основные принципы работы
Основная идея заключается в том, чтобы использовать уникальные идентификаторы, называемые ключами, для связи данных между таблицами. Это позволяет эффективно организовывать и структурировать информацию в базе данных.
Для связи таблиц необходимо определить отношения между ними. Существует три основных типа отношений: один к одному, один ко многим и многие ко многим.
В случае один ко многим, одна запись в одной таблице может быть связана с несколькими записями в другой таблице. Например, таблица «пользователи» может быть связана с таблицей «заказы», где каждый пользователь может иметь несколько заказов.
Для создания связи между таблицами необходимо использовать ключи. Каждая таблица обычно имеет первичный ключ – уникальный идентификатор для каждой записи. Кроме того, таблица может содержать внешний ключ – ссылку на первичный ключ другой таблицы.
В PHP можно использовать различные методы и функции для работы с связанными таблицами. Например, можно использовать оператор JOIN для объединения таблиц и получения нужных данных.
Читать далее: Как найти математическое ожидание при известной дисперсии: полезные советы и примеры расчета
Важно помнить, что при работе с связанными таблицами необходимо правильно организовать структуру базы данных и определить соответствующие ключи и отношения между таблицами. Это позволит эффективно использовать данные и обрабатывать запросы.
Способы связи таблиц
Связь таблиц в MySQL можно осуществить несколькими способами, в зависимости от задачи и структуры данных:
- Один к одному (One-to-One) — каждая запись в одной таблице связана с одной записью в другой таблице.
- Один ко многим (One-to-Many) — каждая запись в одной таблице может быть связана с несколькими записями в другой таблице.
- Многие ко многим (Many-to-Many) — каждая запись в одной таблице может быть связана с несколькими записями в другой таблице, и наоборот.
Для реализации связей между таблицами можно использовать разные подходы:
- Использование внешних ключей — внешний ключ в таблице указывает на первичный ключ в другой таблице, устанавливая связь между ними.
- Использование промежуточных таблиц — для реализации связи многие ко многим можно создать дополнительную таблицу, которая будет содержать внешние ключи от обеих связанных таблиц.
- Использование запросов JOIN — с помощью оператора JOIN можно объединить данные из нескольких таблиц на основе указанных условий связи.
Выбор определенного способа связи зависит от конкретной задачи и требований к структуре данных. Важно правильно спроектировать связи между таблицами, чтобы обеспечить эффективность и правильность работы базы данных.
Связь таблиц через внешние ключи
Внешний ключ определяется на стороне таблицы, которая содержит ссылку на другую таблицу, и указывает на первичный ключ этой другой таблицы. Таким образом, внешний ключ обеспечивает связность записей между таблицами.
Создание связи таблиц через внешние ключи может быть осуществлено при помощи языка SQL. Для этого необходимо определить внешний ключ в таблице, указав поле, на которое будет указывать внешний ключ, и таблицу, на которую он будет ссылаться.
При использовании внешних ключей обеспечивается автоматическая проверка целостности ссылочной целостности данных. Если значение внешнего ключа изменяется или удаляется, то эти изменения распространяются и на связанные записи в другой таблице.
Внешние ключи могут быть использованы для различных целей, включая:
- Управление связностью данных между таблицами;
- Улучшение производительности запросов;
- Запрет на удаление или изменение записи, если на нее есть ссылки в других таблицах;
- Установление правил для вставки данных;
- Определение связи «один-ко-многим» или «многие-ко-многим» между таблицами.
Читать далее: Зачем нужны указатели в C: преимущества и применение
Связь таблиц через внешние ключи позволяет эффективно организовать данные в базе данных и ускорить выполнение запросов. При создании связей следует учитывать структуру и логику данных, чтобы обеспечить оптимальную организацию информации.
Связь таблиц через JOIN-операторы
В MySQL существует несколько типов JOIN-операторов, которые позволяют объединять данные из двух или более таблиц. Это полезно, когда необходимо получить информацию из нескольких связанных таблиц.
Один из наиболее распространенных типов JOIN-операторов — это INNER JOIN. Он возвращает только те строки, которые имеют совпадающие значения в обеих таблицах. Например, если у нас есть таблица «users» со столбцом «id» и таблица «orders» со столбцом «user_id», INNER JOIN позволит нам объединить эти таблицы по значению «user_id» и получить информацию о пользователях, которые сделали заказы.
Еще один тип JOIN-оператора — это LEFT JOIN. Он возвращает все строки из левой таблицы и совпадающие строки из правой таблицы. Если строки в правой таблице не имеют совпадающих значений, то вместо них будет возвращено значение NULL. Например, если у нас есть таблицы «users» и «orders», и мы используем LEFT JOIN для объединения этих таблиц, то будут возвращены все строки из таблицы «users» и соответствующие строки из таблицы «orders», но если у какого-то пользователя нет заказов, то вместо соответствующих значений будет NULL.
Также существуют другие типы JOIN-операторов, такие как RIGHT JOIN и FULL OUTER JOIN, которые возвращают различные комбинации данных из двух таблиц.
Для использования JOIN-операторов в MySQL нужно знать, как связаны таблицы между собой. Для этого обычно используются внешние ключи, которые определяют отношение между таблицами.
Вот пример использования INNER JOIN для связи таблиц «users» и «orders»:
SELECT *
FROM users
INNER JOIN orders ON users.id = orders.user_id;
Этот запрос вернет все столбцы из таблиц «users» и «orders», где значение столбца «id» в таблице «users» равно значению столбца «user_id» в таблице «orders».
Использование JOIN-операторов позволяет эффективно объединять данные из разных таблиц и получать полную информацию о связанных данных.
Примеры использования связей таблиц
Связи таблиц в MySQL позволяют эффективно организовывать и структурировать данные, устанавливая взаимосвязи между различными таблицами. Рассмотрим несколько примеров использования связей таблиц:
1. Одна-к-одной (One-to-One): в этом типе связи одной записи в одной таблице соответствует только одна запись в другой таблице. Например, в таблице «пользователи» может быть поле «адрес», которое ссылается на таблицу «адреса». Это позволяет хранить информацию об адресе каждого пользователя в отдельной таблице и связывать ее с основной таблицей пользователей.
Читать далее: Порядок выполнения действий в математике: основные правила расчетов
2. Одна-ко-многим (One-to-Many): в этом типе связи одной записи в одной таблице соответствует несколько записей в другой таблице. Например, в таблице «категории» может быть поле «продукты», которое ссылается на таблицу «продукты». Это позволяет организовать иерархическую структуру данных, где одна категория может содержать несколько продуктов.
3. Многие-ко-многим (Many-to-Many): в этом типе связи нескольким записям в одной таблице соответствуют несколько записей в другой таблице, и наоборот. Для реализации такой связи необходимо создать дополнительную таблицу, которая будет содержать связи между записями обеих таблиц. Например, в таблице «студенты» может быть поле «курсы», которое ссылается на таблицу «курсы», и наоборот. Таблица «студенты_курсы» будет содержать связи между студентами и курсами.
Это лишь некоторые примеры использования связей таблиц в MySQL через PHP. В зависимости от конкретных требований и структуры данных, можно выбрать наиболее подходящий тип связи и организовать связи между таблицами для эффективного хранения и обработки данных.
Видео по теме:
Отзывы
undefined
Спасибо автору за понятную и информативную статью! Я давно интересуюсь программированием и сейчас изучаю PHP. Конкретно столкнулась с задачей связи таблиц в MySQL, и ваша статья оказалась очень полезной. Я теперь точно понимаю, как это работает и как правильно использовать директивы JOIN и FOREIGN KEY. Кроме того, вы описали различные типы связей между таблицами, что тоже очень помогло мне разобраться в этом вопросе. Большое спасибо за практические примеры и подсказки, они помогли мне лучше усвоить материал. Я уже применила новые знания в своем проекте и результат меня полностью удовлетворил. Теперь я смело могу работать с связанными таблицами в MySQL через PHP!
undefined
Статья очень понравилась! Я давно интересовалась связью таблиц в MySQL через PHP, и эта статья отлично разъяснила основные принципы и способы. Очень понравилось, как автор пошагово объяснил, как создать связь между таблицами с помощью внешних ключей и использовать их для получения связанных данных. Теперь я точно знаю, как использовать JOIN для объединения таблиц и получения данных из обеих таблиц одновременно. Также было очень полезно узнать о различных типах связей, таких как один к одному, один ко многим и многие ко многим. Все объяснено доступным языком и с примерами, что очень помогло мне усвоить материал. Спасибо автору за такую статью и полезную информацию! Теперь я смело могу применять эти знания в своих проектах. Жду новых статей на эту тему!
Как создать первичные и внешние ключи MySQL
В этой инструкции рассказываем про первичный и внешний ключи SQL, зачем они нужны и как их создать различными способами.
Эта инструкция — часть курса «MySQL для новичков».
Смотреть весь курс
Введение
Работа современных приложений и сложных сайтов, которыми мы привыкли пользоваться, невозможна без баз данных. Поэтому правильно настроенные БД важны для приложения не меньше, чем их дизайн и код, который с этой базой взаимодействует. Работа современных реляционных баз данных сложно представить без корректно настроенных первичных и внешних ключей. В этой инструкции мы подробно разберем создание этих ключей MySQL, расскажем для чего они нужны и как их использовать.
Облачные базы данных
Что такое первичный и внешний ключи и зачем они нужны
Начнем рассмотрение данного вопроса с двух самых главных элементов: первичного и внешнего ключей.
Первичный ключ или primary key
Первичный ключ — особенное поле в SQL-таблице, которое позволяет однозначно идентифицировать каждую запись в ней. Как правило, эти поля используются для хранения уникальных идентификаторов объектов, которые перечислены в таблице, например, это может быть ID клиента или товара.
Первичный ключ имеет несколько свойств:
- каждая запись в таком поле должна быть уникальной;
- запись в поле не должна быть пустой;
- в одной таблице может быть только один ключ (существуют также составные ключи, которые могут включать в себя несколько полей, однако в этой статье мы не будем их рассматривать).
Внешний ключ или foreign key
Внешний ключ нужен для того, чтобы связать две разные SQL-таблицы между собой. Внешний ключ таблицы должен соответствует значению первичного ключа таблицы, с которой он связан. Это помогает сохранять согласованность базы данных путем обеспечения так называемой «ссылочной целостности» (referential integrity).
Давайте рассмотрим все это на примере простой базы данных. Для начала нам понадобится создать базу данных. Заходим в MySQL и создаем базу данных, в которой будут храниться записи о книгах в библиотеке:
create database slcbookshelf;
Так как дальше мы будем работать с этой базой, вводим команду:
use slcbookshelf;
И создаем таблицу, в которой будут храниться записи о книгах в библиотеке:
CREATE TABLE books ( book_id INT NOT NULL, book_name VARCHAR(255) NOT NULL, book_category VARCHAR(255));
Создание первичного ключа при создании таблицы и с помощью ALTER TABLE
В созданной выше таблице ни одно из полей не является первичным ключом. Увидеть это мы можем, выполнив команду:
DESC books;
Вывод команды будет выглядеть следующим образом:
mysql> DESC books; +---------------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------------+--------------+------+-----+---------+-------+ | book_id | int | NO | | NULL | | | book_name | varchar(255) | NO | | NULL | | | book_category | varchar(255) | YES | | NULL | | +---------------+--------------+------+-----+---------+-------+ 3 rows in set (0.00 sec)
Первичный ключ при создании таблицы
Вы можете также создать его при создании таблицы, добавив в команду для создания таблицы следующую запись:
PRIMARY KEY (book_id)
В таком случае поле book_id после создания таблицы будет являться первичным ключом для таблицы books.
Создание первичного ключа при помощи ALTER TABLE
Если таблица уже создана, а первичный ключ в ней не указан, вы можете создать ключевое поле, с помощью команды ALTER TABLE. Команда ALTER TABLE помогает изменять уже существующие столбцы, удалять их или добавлять новые. Чтобы определить первичный ключ в поле book_id, выполните команду:
ALTER TABLE books ADD PRIMARY KEY (book_id); Проверяем: mysql> DESC books; +---------------+--------------+------+-----+---------+-------+ | Field | Type | Null | Key | Default | Extra | +---------------+--------------+------+-----+---------+-------+ | book_id | int | NO | PRI | NULL | | | book_name | varchar(255) | NO | | NULL | | | book_category | varchar(255) | YES | | NULL | | +---------------+--------------+------+-----+---------+-------+ 3 rows in set (0.00 sec)
Установка внешнего ключа MySQL при создании таблицы и с помощью ALTER TABLE
Предположим, у нас есть еще одна таблица под названием authors, которую нам необходимо связать с текущей таблицей books с помощью внешнего ключа author_id.
Внешний ключ при создании таблицы
Для того, чтобы привязать к таблице внешний ключ сразу при создании таблицы, вам необходимо дополнить запрос, которым вы создаете таблицу следующей записью:
FOREIGN KEY (author_id) REFERENCES authors(author_id)
В итоге запрос, которым создается такая таблица будет выглядеть следующим образом:
CREATE TABLE books ( book_id INT NOT NULL, book_name VARCHAR(255) NOT NULL, book_category VARCHAR(255), FOREIGN KEY (author_id) REFERENCES authors(author_id));
Создание внешнего ключа при помощи ALTER TABLE
Если вам нужно определить поле уже созданной таблицы в качестве внешнего ключа, вы можете воспользоваться командой ALTER TABLE и создать внешний ключ в таблице командой:
ALTER TABLE books ADD FOREIGN KEY (author_id) REFERENCES authors(author_id);
Сценарии использования внешнего ключа
Внешний ключ является очень важным и мощным инструментом в работе современных баз данных. С помощью внешнего ключа, например, вы можете настроить параметры, которые зададут действия при удалении или обновлении строки в таблице, настроить каскадное удаление или запретить изменять строку в таблице. Давайте рассмотрим на примерах.
Каскадное удаление или CASCADE
Каскадное удаление позволит вам одновременно удалить строки из главной таблицы, а вместе с ними удалить все связанные строки в других таблицах. Задается каскадное удаление таким запросом:
CREATE TABLE Orders( Id INT PRIMARY KEY AUTO_INCREMENT, CustomerId INT, CreatedAt Date, FOREIGN KEY (CustomerId) REFERENCES Customers (Id) ON DELETE CASCADE);
Аналогично работает метод ON UPDATE CASCADE. При попытке изменить значение, записанное в поле первичного ключа, изменение будет применено к внешнему ключу, связанному с данным полем. Этот метод используется крайне редко, так как первичные ключи практически не являются изменяемыми полями.
RESTRICT
Опция RESTRICT позволяет отклонять все запросы на изменение или удаление строк в главной таблице при условии, что в связанной таблице также имеются строки. Задается данное ограничение следующим запросом:
CREATE TABLE Orders( Id INT PRIMARY KEY AUTO_INCREMENT, Customer_Id INT, CreatedAt Date, FOREIGN KEY (Customer_Id) REFERENCES Customers (Id) ON DELETE RESTRICT);
Заключение
В данной статье мы рассмотрели что такое первичный и внешний ключи SQL, зачем они нужны и как их создать различными способами: при создании таблицы или при помощи ALTER TABLE. Также мы рассмотрели несколько сценариев использования внешнего ключа для управления таблицами.
Как установить и использовать MySQL Workbench
Как сделать связь в MySQL?
Здравствуйте!
В интернете почитал статье и смотрел видео уроки но у меня никак не получается создать связь между таблицам
итак допустим есть два таблица
1 — post (id, status, date)
2 — post_content (id, parent_id, language, name, content)
при удаления поста нужно удалить его все контенты которые в разных языках
как можно это сделать?
у меня версия MySQL 5.7
в phpMyAdmin как сделать? или нужен запрос
по моему я не очень хорошо понял связать их
- Вопрос задан более трёх лет назад
- 2751 просмотр
Комментировать
Решения вопроса 1
Для правильного вопроса надо знать половину ответа
Если я правильно понял, то здесь у вас связь один-ко многим, поле `post_content`.`parent_id` указывает на `post`.`id`.
Для того, чтобы создать такую связь (внешний ключ, FOREIGN KEY) в MySQL сначала необходимо убедиться, что оба этих поля имеют одинаковый тип и размер и в колонке `post_content`.`parent_id` нет значений, отсутствующих в `post`.`id`.
Затем надо создать саму связь
ALTER TABLE `post_content` ADD CONSTRAINT FOREIGN KEY `fk_parent_id` (`parent_id`) REFERENCES `post` (`id`) ON DELETE CASCADE;
Этот запрос добавляет внешний ключ `fk_parent_id` с поля `parent_id` на `post`.`id` и говорит, что при удалении записи из таблицы `post` будут удалены связанные записи из `post_content`.
Ответ написан более трёх лет назад
Нравится 2 3 комментария
Дилик Пулатов @dilikpulatov Автор вопроса
спасибо большой. я точно такое делал но в место CASCADE использовал RESTRICT, поэтому у меня не получилось. просто не понимал зачем это)
Дилик Пулатов @dilikpulatov Автор вопроса
есть ещё один вопрос..
есть таблица категории
id, parent_id, status
а когда удаляю категорию, можно удалить её под категории с помощью связь?
Дилик Пулатов, Удалить можно, но не более 15 уровней вложенности. И записи верхнего уровня в такой таблице должны будут иметь `parent_id` = NULL.