Ієрархії даних - частина 1.1: Помічник із ядром EF
Список приналежностей - найпростіший і найінтуїтивніший підхід до зберігання ієрархічних даних. - кожна рядка просто вказує на її батьківщину. . Це МSK2 це те, що більшість розробників досягають для початку M SK3 та для поверхневих дерев з частими рухами. МСК4 це ММСК5 це часто правильний вибір.ММСК6 Цей artykuł охоплює деталі розробки МНСК7 включаючи рекурсивні CTE для перетинання дерева і створення вбудованих структур для інтерфейсу користувача.
Навігація серії
- Частина 1: Обзор - Вprowadzenie та порівняння
- Частина 1.1: Допомічник (таков artykułМSK1
- Частина 1.2: Закривальний стіл
- Частина 1.3: Матеріалізований шлях
- Частина 1.4: Насаджені набіри
- Частина 1.5: ltree
Що таке adjacent list?
Модель списку прилегленості ( - це термін, coined by Джо Селко) - це підхід, до якого звертаються більшість розробників першими , і з добрим причиною МSK2 він МSK3 інтуїтивний МСК4 Кожний вузол просто зберігає інформацію про свій батьківський зв 'язок М СК5 Якщо ви(M СК6) коли-небудь малювали родовідне дерево M СК7 ви(М СК8) вже зрозуміли цю модель М S К9
Ключеві характеристики: кожен ряд знає тільки про свого найближчого батька. Щоб знайти бабусь і дідусю, або внуків, вам потрібно багато пошуків чи рекурсивних запитів
Це найпоширеніша документована модель, і її добре підтримують EF Core's self-referencing relationships.
Визначення об 'єкту
Об 'єкт надзвичайно простий. - ми просто додаємо нульове я .
public class Comment
{
public int Id { get; set; }
public string Content { get; set; } = string.Empty;
public string Author { get; set; } = string.Empty;
public DateTime CreatedAt { get; set; }
// Foreign key - which blog post this comment belongs to
public int PostId { get; set; }
public BlogPost Post { get; set; } = null!;
// ========== ADJACENCY LIST: The hierarchy is defined by these three properties ==========
// ParentCommentId is nullable because:
// - Root-level comments (direct replies to the post) have NULL
// - Nested replies have the ID of the comment they're replying to
public int? ParentCommentId { get; set; }
// Navigation property to load the parent comment when needed
// Useful for breadcrumb trails: "Post > Comment by Alice > Comment by Bob"
public Comment? ParentComment { get; set; }
// Navigation property to load immediate children (NOT grandchildren!)
// EF Core populates this when you use .Include(c => c.Children)
// NOTE: This only gives you ONE level deep - you won't see replies to replies
public ICollection<Comment> Children { get; set; } = new List<Comment>();
}
Конфігурація ядра EF
Конфигурація встановлює зв 'язок самовідповідання і, що важливо, додає індекси для запитів, які ми проводимо найбільш часто
public class CommentConfiguration : IEntityTypeConfiguration<Comment>
{
public void Configure(EntityTypeBuilder<Comment> builder)
{
builder.HasKey(c => c.Id);
builder.Property(c => c.Content)
.IsRequired()
.HasMaxLength(10000);
builder.Property(c => c.Author)
.IsRequired()
.HasMaxLength(200);
// Standard relationship: comment belongs to a blog post
// Cascade delete here is safe - deleting a post should remove all its comments
builder.HasOne(c => c.Post)
.WithMany(p => p.Comments)
.HasForeignKey(c => c.PostId)
.OnDelete(DeleteBehavior.Cascade);
// ========== THE SELF-REFERENCING RELATIONSHIP ==========
// This is what makes it an adjacency list - each comment points to its parent
builder.HasOne(c => c.ParentComment)
.WithMany(c => c.Children) // One parent has many children
.HasForeignKey(c => c.ParentCommentId)
.OnDelete(DeleteBehavior.Restrict); // WARNING: Don't use Cascade here!
// Why Restrict and not Cascade?
// With Cascade, deleting a parent would automatically delete ALL children,
// grandchildren, etc. This can be:
// 1. Unexpected behaviour for users
// 2. A database performance issue (many deletes)
// 3. A data integrity risk (accidental mass deletion)
// Better to handle subtree deletion explicitly in application code
// ========== INDEXES: Critical for performance ==========
// Index on ParentCommentId - used when loading children
// "SELECT * FROM comments WHERE parent_comment_id = @id"
builder.HasIndex(c => c.ParentCommentId);
// Index on PostId - used when loading all comments for a post
// "SELECT * FROM comments WHERE post_id = @id"
builder.HasIndex(c => c.PostId);
// Composite index for the most common query:
// "Get all comments for a post, ordered by creation date"
builder.HasIndex(c => new { c.PostId, c.CreatedAt });
}
}
Карта бази даних
Результатова схема є мінімальною: - лише один セルб - foreign key МSK2
erDiagram
COMMENT {
int id PK
string content
string author
datetime created_at
int post_id FK
int parent_comment_id FK "nullable - NULL for root comments"
}
BLOG_POST {
int id PK
string title
string content
}
BLOG_POST ||--o{ COMMENT : "has"
COMMENT ||--o{ COMMENT : "has children"
Операції
Вsert a New Comment
Вставлення дуже прості. - тут pattern списку прилегленості справді світиться
public async Task<Comment> AddCommentAsync(
int postId,
int? parentId, // NULL for root comment, parent's ID for a reply
string author,
string content,
CancellationToken ct = default)
{
// Creating a comment is just setting the parent reference
// No need to update closure tables, recalculate paths, or renumber anything
var comment = new Comment
{
PostId = postId,
ParentCommentId = parentId, // This single reference defines the hierarchy
Author = author,
Content = content,
CreatedAt = DateTime.UtcNow
};
context.Comments.Add(comment);
await context.SaveChangesAsync(ct);
logger.LogInformation("Added comment {CommentId} to post {PostId}", comment.Id, postId);
return comment;
}
Отримайте безпосередні діти
Один indexed query - швидкий і простий
public async Task<List<Comment>> GetChildrenAsync(int commentId, CancellationToken ct = default)
{
// This is WHERE adjacency lists shine - getting children is trivial
// Single indexed lookup: WHERE parent_comment_id = @id
return await context.Comments
.AsNoTracking() // Read-only, no tracking overhead
.Where(c => c.ParentCommentId == commentId) // Uses the index we defined
.OrderBy(c => c.CreatedAt) // Chronological order
.ToListAsync(ct);
}
Уявіть собі попередники (Hard Part)
Тут' ті, де списку прилегленості показують їхню слабкість . Без рекурсивних запитів M SK2 вам ' потрібно робити багато поїздок по колу МSK4 дістатись батька MSC5 діставатись батька
Щиро дякую. Рекурсивні CTE (WITH RECURSIVEM SK1 прийти на допомогу
public async Task<List<Comment>> GetAncestorsAsync(int commentId, CancellationToken ct = default)
{
// WHY RAW SQL?
// EF Core doesn't have great support for recursive CTEs
// We need to drop down to raw SQL for this
// HOW THE CTE WORKS:
// 1. Start with the target comment (WHERE id = {0})
// 2. UNION ALL joins each result with its parent (JOIN on parent_comment_id)
// 3. PostgreSQL keeps doing this until no more parents are found
// 4. We exclude the starting comment (WHERE id != {0}) to get only ancestors
var sql = @"
WITH RECURSIVE ancestors AS (
-- Base case: start with our target comment
SELECT * FROM comments WHERE id = {0}
UNION ALL
-- Recursive case: join each result with its parent
SELECT c.*
FROM comments c
INNER JOIN ancestors a ON c.id = a.parent_comment_id
)
-- Return all ancestors except the starting comment, in ID order (root first)
SELECT * FROM ancestors WHERE id != {0}
ORDER BY id";
return await context.Comments
.FromSqlRaw(sql, commentId)
.AsNoTracking()
.ToListAsync(ct);
}
Полне піддерево з глибиною
Також потрібен рекурсивний CTE, але цього разу ми відслідковуємо глибину під час руху
public async Task<List<CommentWithDepth>> GetDescendantsWithDepthAsync(
int commentId,
CancellationToken ct = default)
{
// Similar to ancestors, but we go DOWN the tree instead of UP
// We also track depth so we know how to indent in the UI
var sql = @"
WITH RECURSIVE descendants AS (
-- Base case: start with our target comment at depth 0
SELECT *, 0 as depth FROM comments WHERE id = {0}
UNION ALL
-- Recursive case: find children of each result, incrementing depth
SELECT c.*, d.depth + 1
FROM comments c
INNER JOIN descendants d ON c.parent_comment_id = d.id
)
-- Return all descendants, ordered for display
-- depth first, then by creation time within each level
SELECT id, content, author, created_at, post_id, parent_comment_id, depth
FROM descendants
WHERE id != {0}
ORDER BY depth, created_at";
// Note: We need a special DTO to capture the depth column
// EF Core's FromSqlRaw won't automatically map extra columns to entity properties
return await context.Database
.SqlQueryRaw<CommentWithDepth>(sql, commentId)
.ToListAsync(ct);
}
// DTO to hold comment data plus computed depth
public class CommentWithDepth
{
public int Id { get; set; }
public string Content { get; set; } = string.Empty;
public string Author { get; set; } = string.Empty;
public DateTime CreatedAt { get; set; }
public int PostId { get; set; }
public int? ParentCommentId { get; set; }
public int Depth { get; set; } // Computed by the CTE
}
Збудувати структуру Nested Tree для інтерфейсу
Зазвичай, для renderingu необхідна структура дерева.
public async Task<List<CommentTreeNode>> GetCommentTreeAsync(int postId, CancellationToken ct = default)
{
// STRATEGY:
// 1. Load ALL comments for the post in a single query (fast, one round trip)
// 2. Build the tree structure in memory (also fast, just pointer manipulation)
// Step 1: Get all comments for this post
var allComments = await context.Comments
.AsNoTracking()
.Where(c => c.PostId == postId)
.OrderBy(c => c.CreatedAt) // Consistent ordering
.ToListAsync(ct);
// Step 2: Create a lookup by parent ID
// This gives us O(1) access to children of any comment
var lookup = allComments.ToLookup(c => c.ParentCommentId);
// Step 3: Build the tree starting from root comments (ParentCommentId = null)
return BuildTree(lookup, null);
}
private List<CommentTreeNode> BuildTree(
ILookup<int?, Comment> lookup,
int? parentId)
{
// Recursively build tree nodes
// lookup[parentId] gives us all comments whose parent is 'parentId'
return lookup[parentId]
.Select(c => new CommentTreeNode
{
Comment = c,
Children = BuildTree(lookup, c.Id) // Recurse to get children
})
.ToList();
}
public class CommentTreeNode
{
public Comment Comment { get; set; } = null!;
public List<CommentTreeNode> Children { get; set; } = new();
// Convenience property for UI
public bool HasChildren => Children.Count > 0;
}
Утворити піддерево
Для видалення потрібно спочатку знайти усіх потомків:
public async Task DeleteSubtreeAsync(int commentId, CancellationToken ct = default)
{
// We need to find and delete all descendants, then the comment itself
// Using a CTE to get all IDs, then bulk delete
var sql = @"
WITH RECURSIVE subtree AS (
SELECT id FROM comments WHERE id = {0}
UNION ALL
SELECT c.id FROM comments c
INNER JOIN subtree s ON c.parent_comment_id = s.id
)
DELETE FROM comments WHERE id IN (SELECT id FROM subtree)";
var deleted = await context.Database.ExecuteSqlRawAsync(sql, new object[] { commentId }, ct);
logger.LogInformation("Deleted {Count} comments in subtree rooted at {CommentId}",
deleted, commentId);
}
Переміщувати піддерево
Ось де список приналежностей справді світиться. - рух - банальний :
public async Task MoveSubtreeAsync(
int commentId,
int newParentId,
CancellationToken ct = default)
{
// In adjacency list, moving a subtree is just updating ONE row!
// All descendants automatically move with their parent because
// their ParentCommentId still points to their direct parent
var comment = await context.Comments.FindAsync(new object[] { commentId }, ct);
if (comment == null)
{
throw new InvalidOperationException($"Comment {commentId} not found");
}
// Prevent creating a cycle (moving a node under its own descendant)
// This would create an infinite loop in our tree
var ancestors = await GetAncestorsAsync(newParentId, ct);
if (ancestors.Any(a => a.Id == commentId))
{
throw new InvalidOperationException("Cannot move a comment under its own descendant");
}
comment.ParentCommentId = newParentId;
await context.SaveChangesAsync(ct);
logger.LogInformation("Moved comment {CommentId} to new parent {NewParentId}",
commentId, newParentId);
}
Візуалізація потоку запитів
sequenceDiagram
participant App as Application
participant EF as EF Core
participant DB as PostgreSQL
Note over App,DB: Getting Children (Simple - O(1))
App->>EF: GetChildrenAsync(commentId)
EF->>DB: SELECT * FROM comments WHERE parent_id = @id
DB-->>EF: Results (indexed lookup)
EF-->>App: List<Comment>
Note over App,DB: Getting Ancestors (Recursive - O(d) where d=depth)
App->>EF: GetAncestorsAsync(commentId)
EF->>DB: WITH RECURSIVE ancestors AS (...)
DB->>DB: Traverse parent_id chain recursively
DB-->>EF: All ancestors
EF-->>App: List<Comment>
Характеристики ефективності
| Операція МSK1 Сложність МSK2 Перехіди в базу даних | Примітки M | |||||
|---|---|---|---|---|---|---|
| Вставляйте | OM SK2 МSK3 \1 | Просто встановіть ParentCommentId МSK6 | ||||
| Приймайте дітей МSK1 OM SK2 МSK3 | 4 | 5 | Індексований пошук | |||
| Згадайте предків | OM SK2d МSK4 ♫ ♫ МSK5 \з СТК МSK7 ♫ | d ♫= глибина ♫ | ||||
| Візьміть піддерево | OM SK2n МSK4 ♫ ♫ МSK5 | ♫ з CTE ♫ | ||||
| Переміщайте піддерево | OM SK2 МSK3 ♫ ♫ МSK4 ♫ | ♫ Просто оновлюйте один рядок ♫ | ||||
| Використовуйте піддерево МSK1 OM SK2n МSK4 \1 | (з допомогою CTE ) ♫ \ | \ n ♫ = \ розмір піддерева \ МSK10 \ |
Привілеї та мінуси
| Преподобання МSK1 Загнічення | |
|---|---|
| Прості для розуміння та втілення | |
| Minimalне зберігання надрахунку (одна додаткова колонка МSK2 МSK3 Рекурсивні CTE можуть бути повільними на дуже глибоких деревах | |
| Переміщення піддербів є банальним. | |
| EF Корневі навігаційні властивості працюють природно | Неможливо МSK2 легко підрахувати потомків, не завантажуючи їх |
| Немає надлишків даних для підтримки |
Коли використовувати список близьких
Виберите список сусідств, коли:
- Ваша ієрархія невелика. ( менше, ніж 5-6 рівні.
- Ви часто переміщуєте підземні дерева
- Ви хочете, щоб навігаційні властивості EF Core' працювали природно
- Прості вимоги, де рекурсивні CTE є прийнятними
- Вsert performance is more important than read performance
Уникніть списку близькостей, коли:
- У вас є глибокі ієрархії (10+ рівні МSK1
- Ви часто запитуєте: "всякох потомків
- Рідність читання є вирішальним
- Потрібно рахувати потомків, не завантажуючи їх.
Навігація серії
- Частина 1: Обзор
- Частина 1.1: Допомічник (таков artykułМSK1
- Частина 1.2: Закривальний стіл
- Частина 1.3: Матеріалізований шлях
- Частина 1.4: Насаджені набіри
- Частина 1.5: ltree