Занятие 5-3. определение связи «многие ко многим»

Отношение «один-к-одному»

Отношение или связь «один-к-одному» связывает одну запись таблицы с одной или не связывает ни с одной записью другой таблицы. Иногда этот тип отношения применяется для разбиения таблицы с большим количеством полей на две или несколько меньших таблиц.

Таблица Products (изделия) может содержать подробную информацию, описывающую изделие и его цену, и дополнительные сведения об особенностях его производства.

Эти сведения интересны только сотрудникам инженерно-технических подразделений, поэтому их можно перенести в отдельную таблицу (названную, например, ProductsEngineering (технические характеристики изделия). Это та информация, которая не должна интересовать продавцов при оформлении заказов.

В другой ситуации можно разбить таблицу на две, просто потому что она слишком велика. (Программа Access не разрешает таблице иметь более 255 полей.)

Рис. 5.15. Когда связываются два поля, в которых не допускаются дублирующиеся данные (и флажок Обеспечение целостности данных установлен), Access считает, что создается связь «один-к-одному».

Программа помещает цифру 1 на концах линии связи для того, чтобы отличать ее от других типов связей.

В этом примере столбец ID в таблице Products и столбец ID в таблице ProductsEngineering — первичные ключи соответствующих таблиц, поэтому невозможно связать несколько записей таблицы ProductsEngineering с одной и той же записью таблицы Products

создается так же, как отношение «один-ко-многим» — перетаскиванием с помощью мыши полей на вкладке Схема данных (рис. 5.15). Единственная

разница состоит в том, что всвязанных полях обеих таблиц нужно задать запрет совпадений. В этом случае запись одной таблицы может (как максимум) быть связана с единственной записью в другой таблице.

Примечание

В поле запрещены совпадения, если оно является первичным ключом таблицы (см. разд. «Первичный ключ» главы 2) или если у поля есть индекс, препятствующий появлению дублирующейся информации (см. разд. «Предотвращение дублирования значений с помощью индексов» главы 4).

Применяйте связи «один-к-одному» с осторожностью

Отношения «один-к-одному» крайне редко применяются в программе Access. Обычно гораздо удобнее использовать скрытие столбцов (см. разд. «Скрытие столбцов» главы 3) и запросы (см. главу 6), если вы хотите видеть только отдельные поля таблицы.

•    Две части таблицы необходимо поместить в отдельные БД (см. разд. «Что такое разделенная БД» главы 18) для того, чтобы разные люди могли копировать их на разные компьютеры и редактировать независимо.

•    Вы хотите защитить от любопытных глаз уязвимые данные. Один из возможных способов — поместить информацию, которую нужно защитить, в отдельную таблицу и сохранить эту таблицу в другой, более защищенный файл БД.

•    У вас есть таблица с огромным объемом данных, таких как поля типа Вложение (см. разд. «Вложение» главы 2) с большими документами. В этом случае можно повысить производительность, если разделить таблицу. Вы даже можете решить, что лучше поместить половину таблицы в отдельную БД (см, разд. «Что такое разделенная БД» главы 18).

•    Некоторые данные вашей таблицы необязательны. Вместо того чтобы включать большое количество незаполненных полей, можно выделить их в отдельную таблицу. Когда не нужно включать эту информацию, вам не придется добавлять запись в связанную таблицу.

Если у вас нет таких ситуаций, вы больше выиграете от создания одной большой таблицы.

Отношение «многие-ко-многим»

Отношение или связь «многие-ко-многим»связывает одну или несколько записей одной таблицы с одной или несколькими записями в другой таблице. Рассмотрим БД, в которой в отдельных таблицах хранятся данные об авторах и книгах.

Авторы бестселлеров не останавливаются на одной книге (поэтому вы должны иметь возможность связать одного автора с несколькими книгами).

Однако иногда авторы объединяются в команду под одним заглавием (поэтому вы должны иметь возможность связать одну книгу с несколькими авторами).

Аналогичная ситуация возникает, если нужно распределить студентов по курсам, сотрудников по комитетам или ингредиенты по рецептам. Можно даже представить подобную ситуацию и в случае БД с куклами-болванчиками, если несколько изготовителей решат объединиться для изготовления одной куклы-болванчика.

Связи «многие-ко-многим» довольно распространены, и программа Access предоставляет два способа их обработки.

Вы можете следить за любыми ответами на эту запись через RSS 2.0 ленту. Вы можете оставить ответ, или trackback с вашего собственного сайта.

Многие ко многим С Новой сущностью

4.1. Моделирование атрибутов отношений

Допустим, мы хотим, чтобы студенты регистрировались на курсы. Кроме того, нам нужно сохранить точку, когда студент зарегистрировался на определенный курс. Кроме того, мы хотим сохранить, какую оценку она получила на курсе.

В идеальном мире мы могли бы решить эту проблему с помощью предыдущего решения, где у нас была сущность с составным ключом. Однако мир далек от идеала, и студенты не всегда заканчивают курс с первой попытки.

В этом случае существует несколько соединений между одними и теми же парами студент-курс или несколькими строками с одинаковыми парами student_id-course_id . Мы не можем смоделировать его с помощью любого из предыдущих решений, потому что все первичные ключи должны быть уникальными. Итак, нам нужно использовать отдельный первичный ключ.

Поэтому мы можем ввести сущность , которая будет содержать атрибуты регистрации:

В этом случае объект регистрации представляет отношения между двумя другими объектами.

Поскольку это сущность, у нее будет свой собственный первичный ключ.

В предыдущем решении помните, что у нас был составной первичный ключ, который мы создали из двух внешних ключей.

Теперь два внешних ключа не будут частью первичного ключа:

4.2. Внедрение в JPA

Поскольку course_registration стала обычной таблицей, мы можем создать простую старую сущность JPA, моделирующую ее:

@Entity
class CourseRegistration {

    @Id
    Long id;

    @ManyToOne
    @JoinColumn(name = "student_id")
    Student student;

    @ManyToOne
    @JoinColumn(name = "course_id")
    Course course;

    LocalDateTime registeredAt;

    int grade;
    
    // additional properties
    // standard constructors, getters, and setters
}

Нам также необходимо настроить отношения в классах Student и Course :

class Student {

    // ...

    @OneToMany(mappedBy = "student")
    Set registrations;

    // ...
}

class Course {

    // ...

    @OneToMany(mappedBy = "courses")
    Set registrations;

    // ...
}

Опять же, мы настроили отношения ранее, поэтому нам нужно только сообщить JPA, где он может найти эту конфигурацию.

Мы также могли бы использовать это решение для решения предыдущей проблемы рейтинговых курсов студентов. Тем не менее, кажется странным создавать выделенный первичный ключ, если в этом нет необходимости.

Более того, с точки зрения СУБД это не имеет особого смысла, поскольку объединение двух внешних ключей сделало идеальный составной ключ. Кроме того, этот составной ключ имел четкое значение: какие сущности мы соединяем в отношениях.

В противном случае выбор между этими двумя реализациями часто является просто личным предпочтением.

Один к одному (one-to-one)

Связь один к одному это когда одной записи в таблице отвечает только одна запись из другой таблицы. Чтобы продемонстрировать связь один к одному возьмем таблицу supplier:

и вынесем колонку full_address в отдельную таблицу. Таким образом в таблице supplier будет ссылка на таблицу address, в которой будут такие поля: address_id, coutry, city, street.

Не теряя времени сделаем нужные изменения.

alter table supplier modify column full_address int;

Так как поле full_address будет ссылкой на таблицу address сделаем его тип целочисленным.

Далее создадим саму таблицу address.

create table address(address_id int auto_increment primary key, country text, city text, street text);

Теперь укажем, что поле full_address будет внешним ключом:

alter table supplier add foreign key (full_address) references address(address_id);

Связь один к одному означает, что в таблице supplier будет уникальный идентификатор записи с таблицы address. Поэтому, нужно сделать поле full_address уникальным:

alter table supplier add foreign key (full_address) references address(address_id);

Теперь, каждый адрес будет относиться только к одному поставщику и все попытки добавить поставщику адрес другого поставщика будет приводить к ошибке.

Связь типа «один-к-одному»

При связи типа «один-к-одному» каждой записи в главной таблице может соответствовать не более одной записи в подчиненной таблице, и наоборот, каждая запись в подчиненной таблице не может иметь более одной соответствующей ей записи в главной таблице (например, у гражданина страны есть только один паспорт, а не много).

Этот тип связи применяется реже, так как такие данные могут быть помещены в одну таблицу. Связь типа «один-к-одному» обычно используют для разделения таблиц, имеющих много полей, а также для сохранения сведений, относящихся к подмножеству записей в главной таблице. Например, такой тип связи использован при установлении связей между таблицами Студенты и Общежитие (см. рис.3.2).

Рис. 3.2. Связи между таблицами в БД Деканат

INNER JOIN

Прежде чем идти дальше и рассматривать другие типы связей, стоит изучить ещё один оператор SQL — INNER JOIN. Он используется для объединения строк из двух и более таблиц, основываясь на отношениях между ними. Для запроса используется следующий синтаксис:

Чтобы получить всех пользователей вместе с их профилями нам нужно выполнить следующий запрос:

Каждая строка из левой таблицы, сопоставляется с каждой строкой из правой таблицы, после этого проверяется условие.

Если мы хотим выбрать только некоторые столбцы, то после оператора SELECT нужно перед именем поля явно указать название таблицы, из которой оно берется:

Mapping отношений Многие к Одному.

В этом примере каждая категория может быть связана со многими продуктами. Но каждый продукт может быть связан только с одной категорией. Это отношение можно обобщить следующим образом: множество товаров для одной категории (или, что то же самое, одна категория для множества товаров).

С точки зрения сущности «Продукт» это отношение «многие к одному». С точки зрения сущности Category это отношение один ко многим.

Чтобы отобразить это, сначала создайте свойство категории в классе Product с аннотацией ManyToOne. Вы можете сделать это вручную или с помощью команды make:entity, которая задаст вам несколько вопросов о ваших отношениях. Если вы не уверены в ответе, не волнуйтесь! Вы всегда можете изменить настройки позже:

 php bin/console make:entity

Class name of the entity to create or update (e.g. BraveChef):
> Product

 to stop adding fields):
> category

Field type (enter ? to see all types) :
> relation

What class should this entity be related to?:
> Category

Relation type? :
> ManyToOne

Is the Product.category property allowed to be null (nullable)? (yes/no) :
> no

Do you want to add a new property to Category so that you can access/update
getProducts()? (yes/no) :
> yes

New field name inside Category :
> products

Do you want to automatically delete orphaned App\Entity\Product objects
(orphanRemoval)? (yes/no) :
> no

 to stop adding fields):
>
(press enter again to finish)

Это внесло изменения в две сущности. Во-первых, он добавил новое свойство category в сущность Product (и методы getter & setter):

// src/Entity/Product.php

// ...
class Product
{
    // ...

    /**
     * @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="products")
     */
    private $category;

    public function getCategory(): ?Category
    {
        return $this->category;
    }

    public function setCategory(?Category $category): self
    {
        $this->category = $category;

        return $this;
    }
}

Это сопоставление ManyToOne требуется. Он говорит Doctrine использовать столбец category_id в таблице продуктов, чтобы связать каждую запись в этой таблице с записью в таблице категорий.

Далее, поскольку один объект Category будет относиться ко многим объектам Product, команда make: entity также добавила свойство products в класс Category, который будет содержать эти объекты:

// src/Entity/Category.php

// ...
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;

class Category
{
    // ...

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Product", mappedBy="category")
     */
    private $products;

    public function __construct()
    {
        $this->products = new ArrayCollection();
    }

    /**
     * @return Collection|Product[]
     */
    public function getProducts(): Collection
    {
        return $this->products;
    }

    // addProduct() and removeProduct() were also added
}

Отображение ManyToOne, показанное ранее, является обязательным, но это OneToMany не является обязательным: добавляйте его только в том случае, если вы хотите иметь доступ к продуктам, которые относятся к категории (это один из вопросов, которые задает make: entity вас спрашивает). В этом примере будет полезно иметь возможность вызывать $ category-> getProducts (). Если вы не хотите этого, то вам также не нужно конфигурация inversedBy или mappedBy.

Связь 1-N — один ко многим

Помним:

у одного клиента — много заказов, нужен список заказов клиента

и тут нюанс — в заказе клиент уже указан:

• зачем создавать и вручную заполнять список заказов..? пахнет костылем
• решение — связь 1-N

Настройка в ELMA:

1. Перейдем в клиента
2. Добавим свойство заказы
3. Укажем тип свойства «Множественная (1-N)» и укажем «ключевую колонку» Клиент из объекта Заказ

дальше интереснее

Посмотрим в базу данных

На диаграмме ничего не поменялось и вот почему:

• база данных знала заранее и нарисовала связь 1-N
• в направлении Заказ -> Клиент соответствие 1-1 , в обратном N-1 ( это пытались сказать разработчики ELMA в начале)

Таблицы выглядят по прежнему:

На этом чудеса не заканчиваются:

1. Добавьте еще один заказ клиенту
2. Теперь откройте карточку клиента

Что тут произошло:

ELMA не создавала новое поле в таблице а только создала список в объекте клиент который определяется по свойству клиент в поле объекта заказ

Нюансы работы со связями 1-1 и 1-N (также работает из кода)

1. Если в заказе указать клиента — он отразится в списке заказов клиента (это известно)
2. Если в список заказов клиента добавить заказ — в добавленном заказе изменится клиент (поэтому будьте уверены что нужна связь 1-N а не N-N, читайте о ней дальше)

Ассоциация ManyToOne / OneToMany.

Предположим, что каждый продукт в вашей заявке относится только к одной категории. В этом случае вам понадобится класс Category и способ связать объект Product объектом Category.

Начните с создания Category с полем name:

 php bin/console make:entity Category

 New property name (press <return> to stop adding fields):
> name

Field type (enter ? to see all types) :
> string

Field length :
> 255

Can this field be null in the database (nullable) (yes/no) :
> no

 New property name (press <return> to stop adding fields):
>
(press enter again to finish)

Это сгенерирует ваш новый класс сущности:

// src/Entity/Category.php
// ...

class Category
{
    /**
     * @ORM\Id
     * @ORM\GeneratedValue
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * @ORM\Column(type="string")
     */
    private $name;

    // ... getters and setters
}

Алиасы

Согласитесь, в прошлом примере пришлось довольно много букв написать. Чтобы этого избежать, в запросах можно использовать алиасы для имён таблиц. Для этого после имени таблицы можно написать AS alias. Давайте для таблицы users зададим алиас — u, а для таблицы profiles — p. Эти алиасы теперь можно использовать в любой части запроса:

Заметьте, запрос сократился. Писать запрос с использованием алиаса быстрее.

Как уже говорилось выше, алиас можно использовать в любой части запроса, в том числе и в условии WHERE:

Один-ко-многим

При такой связи одной записи в одной таблице соответствует несколько записей в другой. В начале этого урока мы рассмотрели как раз такой пример, когда говорили о добавлении в таблицу с новостями поля author_id. Таким образом, у каждой статьи есть один автор. В то же время у одного автора может быть несколько статей.
Давайте создадим таблицу для статей. Пусть в ней будет идентификатор статьи, её название, текст, и идентификатор автора.

Добавим несколько статей:

Запросим теперь эти записи, чтобы убедиться, что всё ок

Давайте теперь выведем имена статей вместе с авторами. Для этого снова воспользуемся оператором INNER JOIN.

Как видим, у Ивана две статьи, и ещё одна у Ольги.

Если бы мы захотели на странице со статьей выводить рядом с автором краткую информацию о нем, нам нужно было бы сделать ещё один JOIN на табличку profiles.

Изи!

Связь один-к-одному

Последнее обновление: 17.05.2019

Отношение один к одному указывает, что одна сущность может владеть другой сущностью в единственном экземпляре. Например, у команды может быть только один тренер. С другой стороны,
тренер может тренировать одновременно только одну команду.

Для создания подобной связи между моделями применяется метод hasOne(). Например, определим модели тренера и команды:

const Sequelize = require("sequelize");

const sequelize = new Sequelize("game", "root", "123456", {
    dialect: "mysql",
    host: "localhost",
    define: {
      timestamps: false
    }
});
const Coach = sequelize.define("coach", {
  id: {
    type: Sequelize.INTEGER,
    autoIncrement: true,
    primaryKey: true,
    allowNull: false
  },
  name: {
    type: Sequelize.STRING,
    allowNull: false
  }
});
const Team = sequelize.define("team", {
  id: {
    type: Sequelize.INTEGER,
    autoIncrement: true,
    primaryKey: true,
    allowNull: false
  },
  name: {
    type: Sequelize.STRING,
    allowNull: false
  }
});

Coach.hasOne(Team, { onDelete: "cascade"});

sequelize.sync({force:true}).then(()=>{

  console.log("Tables have been created");
}).catch(err=>console.log(err));

В данном случае модель тренера (Coach) условно считается главной, а модель команды (Team) зависимой (но в данном случае деление на главную и зависимую модель
достаточно условно). Поэтому метод вызывается у модели Coach, и в качестве первого параметра передается модель Team. Хотя в данном случае не имеет значения, какая именно модель является главной или зависимой.
Второй параметр метода задает конфигурацию связи, в частности, каскадное удаление.

В итоге при выполнении данного когда в MySQL будут созданы следующие таблицы:

CREATE TABLE `coaches` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf-8 COLLATE=utf8mb4_0900_ai_ci;

CREATE TABLE `teams` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL,
  `coachId` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `coachId` (`coachId`),
  CONSTRAINT `teams_ibfk_1` FOREIGN KEY (`coachId`) REFERENCES `coaches` (`id`) ON DELETE CASCADE ON UPDATE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf-8 COLLATE=utf8mb4_0900_ai_ci;

Как мы видим, в таблице teams создается дополнительный столбец coachId, через который данная таблица будет связана с таблицей coaches.

Добавление и получение связанных данных

Для установки связанных данных применяется метод setНАЗВАНИЕ_МОДЕЛИ(). Например, добавим тренера и его команду:

// добавляем тренера
Coach.create({ name: "Tom Smith"})
.then(coach=>{
	// Добавляем команду
	Team.create({name:"Real Madrid"}).then(team=>{
		// устанавливаем для тренера команду
		coach.setTeam(team).catch(err=>console.log(err));
	});
}).catch(err=>console.log(err));

По факту метод будет вызывать SQL-команду UPDATE. То есть к моменту вызова данного метода связываемые сущности уже должны быть в
базе данных.

Для получения связанных данных применяется метод getНАЗВАНИЕ_МОДЕЛИ(). Например, получим тренера и его команду:

// получаем тренера с id=1
Coach.findByPk(1).then(coach=>{
	if(!coach) return console.log("Coach not found");
    coach.getTeam().then(team=>{
        console.log(coach.name, "-", team.name);
    });
});

В данном случае на консоли мы получим:

Tom Smith - Real Madrid

Получение всех тренеров с включением связанных данных:

Coach.findAll({
    attributes: , // включаем столбец name из таблицы coaches
    include:   // включаем столбец name из таблицы teams
    }]
  }).then(coaches => {
      for(coach of coaches){
        console.log(coach.name, "-", coach.team.name);
      }
});

НазадВперед

Связь один-к-одному

Последнее обновление: 31.10.2015

Строго говоря в Entity Framework нет как таковой связи один-к-одному, так как ожидается, что обработчик будет использовать связь
один-ко-многим. Но все же нередко возникает потребность в наличие подобной связи между объектами в приложении, и в Entity Framework мы можем настроить
данный тип отношений.

Рассмотрим стандартный пример подобных отношений: есть класс пользователя User, который хранит логин и пароль, то есть данные учетных записей. А все данные профиля, такие
как имя, возраст и так далее, выделяются в класс профиля UserProfile.

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
//.................................

public class User
{
    public int Id { get; set; }
    public string Login { get; set; }
    public string Password { get; set; }

    public UserProfile Profile { get; set; }
}

public class UserProfile
{
    
    
    public int Id { get; set; }

    public string Name { get; set; }
    public int Age { get; set; }

    public User User { get; set; }
}

В этой связи между классами класс UserProfile является дочерним или подчиненным по отношению к классу User. И чтобы установить связь одни к одному,
у подчиненного класса устанавливается свойство идентификатора, которое называется также, как и идентификатор в основном классе. То есть в классе User свойство называется
Id, то и в UserProfile также свойство называется Id. Если бы в классе User свойство называлось бы UserId, то такое же название должно было быть и в UserProfile.

И в классе UserProfile над этим свойством Id устанавливаются два атрибута: , который показывает, то это первичный ключ, и
, который показывает, что это также и внешний ключ. Причем внешний ключ к таблице объектов User.

Соответственно классы User и UserProfile имеют ссылки друг на друга.

В классе контекста определяются свойства для взаимодействия с талицами в бд:

public class UserContext : DbContext
{
    public DbSet<User> Users { get; set; }
    public DbSet<UserProfile> UserProfiles { get; set; }
}

Для этих классов контекст данных будет создавать следующую таблицу UserProfiles:

CREATE TABLE . (
       INT            NOT NULL,
     NVARCHAR (MAX) NULL,
      INT            NOT NULL,
    CONSTRAINT  PRIMARY KEY CLUSTERED ( ASC),
    CONSTRAINT  FOREIGN KEY () REFERENCES . ()
);

Посмотрим, как работать с моделями с такой связью. Добавление и получение:

using(UserContext db = new UserContext())
{
    User user1 = new User { Login = "login1", Password = "pass1234" };
    User user2 = new User { Login = "login2", Password = "5678word2" };
    db.Users.AddRange(new List<User> { user1, user2 });
    db.SaveChanges();
    UserProfile profile1 = new UserProfile { Id = user1.Id, Age = 22, Name = "Tom" };
    UserProfile profile2 = new UserProfile { Id = user2.Id, Age = 27, Name = "Alice" };
    db.UserProfiles.AddRange(new List<UserProfile> { profile1, profile2 });
    db.SaveChanges();

    foreach(User user in db.Users.Include("Profile").ToList())
        Console.WriteLine("Name: {0}  Age: {1}  Login: {2}  Password: {3}", 
                user.Profile.Name, user.Profile.Age, user.Login, user.Password);
}

Редактирование:

using (UserContext db = new UserContext())
{
    User user1 = db.Users.FirstOrDefault();
    if(user1!=null)
    {
        user1.Password = "dsfvbggg";
        db.Entry(user1).State = EntityState.Modified;
        db.SaveChanges();
    }

    UserProfile profile2 = db.UserProfiles.FirstOrDefault(p => p.User.Login == "login2");
    if(profile2!=null)
    {
        profile2.Name = "Alice II";
        db.Entry(profile2).State = EntityState.Modified;
        db.SaveChanges();
    }
}

При удалении надо учитывать следующее: так как объект UserProfile требует наличие объекта User и зависит от этого объекта, то при удалении связанного
объекта User надо будет удалить и связанный с ним объект UserProfile. Поскольку по молчанию у нас не предусмотрено каскадное даление при данной связи.
Если же будет удален объект UserProfile, на объект User это никак не повлияет:

using (UserContext db = new UserContext())
{
    User user1 = db.Users.Include("Profile").FirstOrDefault();
    if(user1!=null)
    {
        db.UserProfiles.Remove(user1.Profile);
        db.Users.Remove(user1);
        db.SaveChanges();
    }

    UserProfile profile2 = db.UserProfiles.FirstOrDefault(p => p.User.Login == "login2");
    if(profile2!=null)
    {
        db.UserProfiles.Remove(profile2);
        db.SaveChanges();
    }
}

НазадВперед

Добавление необходимых таблиц к представлению источника данных

Откройте конструктор представлений источника данных для представления источников данных Adventure Works DW 2012 .

Щелкните правой кнопкой мыши панель Организатор диаграмм , выберите команду Создать диаграмму и укажите Причина заказа через Интернет в качестве имени созданной диаграммы.

Перетащите таблицу InternetSales с панели Таблицы на панель Диаграмма .

Щелкните правой кнопкой мыши панель Диаграмма и выберите команду Добавить или удалить таблицы.

В диалоговом окне Добавление или удаление таблиц добавьте в список Включенные объекты таблицы DimSalesReason и FactInternetSalesReason , а затем нажмите кнопку ОК.
Обратите внимание, что связи «первичный-внешний ключ» между задействованными таблицами устанавливаются автоматически, поскольку эти связи определяются в базовой реляционной базе данных. Если эти связи не определены в базовой реляционной базе данных, их следует определить в представлении источника данных.

В меню Формат выберите команду Автоматический макет и щелкните значок Диаграмма.

В окне свойств измените свойство FriendlyName таблицы DimSalesReason на SalesReason, затем измените свойство FriendlyName таблицы FactInternetSalesReason на InternetSalesReason.

На панели Таблицы разверните узел InternetSalesReason (dbo.FactInternetSalesReason), щелкните столбец SalesOrderNumber и просмотрите в окне свойств свойство DataType для этого столбца данных.
Обратите внимание, что в качестве типа данных для столбца SalesOrderNumber указан тип данных string.

Просмотрите типы данных для других столбцов таблицы FactInternetSalesReason .
Обратите внимание, что для остальных двух столбцов этой таблицы указаны числовые типы данных.

На панели Таблицы щелкните правой кнопкой мыши таблицу InternetSalesReason (dbo.FactInternetSalesReason) и выберите пункт Просмотр данных.
Обратите внимание, что для каждого номера строки каждого заказа значение ключа указывает причину покупки данной позиции линии, как показано на следующем рисунке.

Глава 3. Связи в access

В созданной базе данных таблицы связаны друг с другом. Для связанных таблиц
изменение некоторых свойств полей
становится невозможным. В связанную
таблицу нельзя добавить новое поле или
удалить существующее поле, но можно
добавить записи, а также изменить
значения отдельных полей. Если связь
установлена с таблицей Access, то доступна
также операция удаления записей.

После того как в БД созданы основные
таблицы, следует указать, как они связаны
друг с другом. Эти связи Access будет
использовать в запросах, формах и отчетах
при отборе информации из нескольких
таблиц. Задание связей между таблицами
позволяет также обеспечить защиту
целостности данных в БД. Окно связей
вызывается командой Схема данныхменюРабота с базой данных(см. рис.
3.1)

Рис. 3.1.

Связь между двумя таблицами, одна из
которых является главной, а другая
подчиненной, устанавливает соответствие
между записями этих таблиц.

Для
установления связи нужно, чтобы в главной
таблице существовало поле или группа
полей, совокупность значений которых
однозначно определяла бы запись (была
уникальной). Обычно в качестве поля
(группы полей) связи выбирается ключевое
поле таблицы, но достаточно, чтобы оно
имело уникальный индекс.

В соответствие
ему ставится поле (группа полей)
подчиненной таблицы, называемое внешним
ключом. Связь между записями устанавливается
по совпадению значений в полях связи.

!!! Поля связи могут иметь разные имена,
но они должны иметь один тип данных и
иметь однотипное содержимое.

Исключение из этого правила: поле типа
Счетчик можно связывать с числовым
полем, имеющим в свойстве Размер поля
значение «Длинное целое». Кроме того,
связываемые поля числового типа должны
иметь одинаковые значения свойстваРазмер поля.

Каждой записи в главной
таблице — данным о студенте — соответствует
несколько (или ни одной) записей из
подчиненной таблицы — информация об
его оценках. Поле Код Студента в таблице
Сессия является внешним ключом.

1. Связь типа «один-ко-многим»

Описанная выше связь между
таблицами Студенты и Сессия — пример
связи типа «один-ко-многим».
Это наиболее распространенный тип
связи.

При таком типе связи каждой записи
в главной таблице могут соответствовать
одна, несколько или ни одной записи в
подчиненной таблице (например, сотрудники
одного отдела: отдел один, а сотрудников
в нем много), а каждая запись в подчиненной
таблице не может иметь более одной
соответствующей ей записи в главной
таблице.

2. Связь типа «один-к-одному»

При связи типа «один-к-одному» каждой
записи в главной таблице может
соответствовать не более одной записи
в подчиненной таблице, и наоборот, каждая
запись в подчиненной таблице не может
иметь более одной соответствующей ей
записи в главной таблице (например, у
гражданина страны есть только один
паспорт, а не много).

Этот тип связи применяется реже, так
как такие данные могут быть помещены в
одну таблицу. Связь типа «один-к-одному»
обычно используют для разделения таблиц,
имеющих много полей, а также для сохранения
сведений, относящихся к подмножеству
записей в главной таблице. Например,
такой тип связи использован при
установлении связей между таблицами
Студенты и Общежитие (см. рис.3.2).

Рис. 3.2. Связи между таблицами в БД Деканат

Вывод

Знание трех типов табличных отношений очень важно, особенно с учетом того, что чаще всего разработчик приложения использует несколько уровней абстракций при взаимодействии с базой данных. Кроме того, при использовании инструмента ORM очень важно проверить связи таблиц, созданные платформой доступа к данным, чтобы убедиться, что они соответствуют стандартному определению и что они не пытаются имитировать связь с использованием неоптимального подхода

Кроме того, при использовании инструмента ORM очень важно проверить связи таблиц, созданные платформой доступа к данным, чтобы убедиться, что они соответствуют стандартному определению и что они не пытаются имитировать связь с использованием неоптимального подхода