Что такое own table поле?

Что такое Owned Entity Types (Own Table) в Entity Framework Core?

Owned Entity Types (владеемые типы сущностей) — это специальная концепция в Entity Framework Core, которая позволяет моделировать сложные типы или объекты-значения, которые не имеют собственного ключа и всегда принадлежат какой-либо основной сущности. Когда такая владеемая сущность сохраняется в отдельной таблице базы данных, это называется Own Table (или Table Splitting).

Основная идея и назначение

Владеемые типы используются для:

• Группировки связанных свойств в отдельный класс для улучшения организации кода.
• Моделирования объектов-значений (Value Objects) из Domain-Driven Design, которые не имеют идентичности.
• Разделения таблицы (Table Splitting) — хранения данных одной сущности в нескольких таблицах.
• Совместного использования типа несколькими свойствами основной сущности.

Конфигурация Owned Type с Own Table

Чтобы сконфигурировать владеемый тип, который будет храниться в отдельной таблице, используется метод .OwnsOne() или .OwnsMany() в OnModelCreating, а затем вызов .ToTable() для указания имени таблицы.

Пример: Профиль пользователя в отдельной таблице

Предположим, у нас есть сущность User и мы хотим вынести его контактные данные в отдельный владеемый тип ContactInfo, который будет храниться в своей таблице.

// Основная сущность
public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public ContactInfo PersonalContact { get; set; } // Владеемое свойство
}

// Владеемый тип (не имеет собственного ключа Id)
public class ContactInfo
{
    public string Email { get; set; }
    public string Phone { get; set; }
    public Address HomeAddress { get; set; } // Вложенный владеемый тип
}

public class Address
{
    public string Street { get; set; }
    public string City { get; set; }
}

Конфигурация в DbContext:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<User>(entity =>
    {
        entity.HasKey(e => e.Id);
        
        // Настраиваем владеемый тип ContactInfo и указываем для него отдельную таблицу
        entity.OwnsOne(e => e.PersonalContact, owned =>
        {
            owned.ToTable("UserContactInfo"); // Ключевой момент: Own Table
            owned.Property(p => p.Email).HasColumnName("ContactEmail");
            owned.Property(p => p.Phone).HasColumnName("ContactPhone");
            
            // Вложенный владеемый тип (будет в той же таблице UserContactInfo)
            owned.OwnsOne(a => a.HomeAddress, address =>
            {
                address.Property(a => a.Street).HasColumnName("HomeStreet");
                address.Property(a => a.City).HasColumnName("HomeCity");
            });
        });
    });
}

Как это работает в базе данных

При такой конфигурации EF Core создаст две таблицы:

1. Users (основная таблица):

    *   `Id` (PK)
    *   `Username`

1. UserContactInfo (owned table):

    *   `User_Id` (FK, связь с Users.Id)
    *   `ContactEmail`
    *   `ContactPhone`
    *   `HomeStreet`
    *   `HomeCity`

Важные особенности:

• Внешний ключ в owned table (User_Id) является также первичным ключом этой таблицы, устанавливая отношение "один к одному".
• Владеемая сущность не может существовать без основной сущности.
• При загрузке User EF Core автоматически выполнит JOIN между таблицами Users и UserContactInfo.
• Все изменения владеемого типа отслеживаются как часть основной сущности.

Преимущества подхода Own Table

1. Нормализация базы данных: логическое разделение данных, даже если они принадлежат одной концептуальной сущности.
2. Производительность: если владеемые данные большие и редко запрашиваются, их можно хранить отдельно для оптимизации чтения основной сущности.
3. Гибкость схемы: можно изменять схему owned table независимо от основной (в разумных пределах).
4. Чистота модели: соответствие принципам DDD, где объекты-значения не имеют идентичности.

Ограничения и важные замечания

• Нет навигационных свойств: владеемый тип не может иметь навигационных свойств к другим сущностям (кроме вложенных владеемых типов).
• Нельзя использовать в качестве основной сущности: владеемый тип не может быть DbSet в контексте.
• Отношение всегда один-к-одному: для OwnsOne с Own Table.
• Миграции: требуется аккуратная работа с миграциями при изменении структуры владеемых типов.
• Запросы: при фильтрации по свойствам owned table EF Core автоматически создает JOIN.

Альтернатива: Owned Type в той же таблице (Table Splitting)

Если не вызывать .ToTable(), владеемые свойства будут сохранены в той же таблице, что и основная сущность, с префиксом в именах столбцов. Это другой вариант Table Splitting.

entity.OwnsOne(e => e.PersonalContact, owned =>
{
    // Без .ToTable() - будет в таблице Users
    owned.Property(p => p.Email).HasColumnName("PersonalEmail");
});

Практическое применение

Own Table поля полезны для:

• Аудита: вынесения полей CreatedBy, ModifiedDate в отдельную таблицу.
• Локализации: хранения переводов в отдельных таблицах.
• Наследования стратегии TPT (Table per Type).
• Разделения часто и редко используемых данных для оптимизации.

В заключение, Owned Entity Types с Own Table — это мощный инструмент EF Core для сложных сценариев моделирования данных, который сочетает преимущества объектно-ориентированного дизайна с гибкостью реляционной схемы, позволяя сохранять целостность доменной модели при работе с базой данных.