Πότε χρειάζονται DDD Aggregate και SQL aggregation σε reads και writes
Μια συνηθισμένη απαίτηση από το frontend είναι να φορτώνουμε τα δεδομένα σταδιακά: πρώτα τη σύνοψη, μετά μια καρτέλα και, όταν χρειαστεί, τις λεπτομέρειές της.
Σε αυτή τη συζήτηση μπορεί να ακουστεί: «Δεν θέλω Aggregate στο read, γιατί δεν χρειάζομαι όλα τα δεδομένα μαζί».
Η απαίτηση για στοχευμένα reads έχει βάση. Χρειάζεται όμως να ξεχωρίσουμε το DDD Aggregate, τη φόρτωση δεδομένων, το SQL aggregation και την απάντηση του API.
Πρόκειται για διαφορετικές αποφάσεις:
| Έννοια | Τι καθορίζει |
|---|---|
| DDD Aggregate | Ποια αντικείμενα συνεργάζονται για να διατηρούν κοινούς επιχειρησιακούς κανόνες |
| DTO projection | Ποια πεδία χρειάζεται η συγκεκριμένη προβολή |
| Pagination | Πόσες βασικές εγγραφές επιστρέφονται ανά αίτημα |
| SQL aggregation | Ποια σύνολα, πλήθη ή άλλες συγκεντρωτικές τιμές υπολογίζουμε |
| Stored procedure | Πώς οργανώνουμε και εκτελούμε συγκεκριμένη λειτουργία στη βάση |
Μια εφαρμογή μπορεί να χρησιμοποιεί όλα τα παραπάνω, ανάλογα με τη λειτουργία.
Δύο διαφορετικές ερωτήσεις για το Aggregate
Πριν επιλέξουμε υλοποίηση, ξεχωρίζουμε δύο ερωτήσεις:
- Χρειάζεται το Domain ένα Aggregate για τους κανόνες του;
- Χρειάζεται η συγκεκριμένη λειτουργία να δημιουργήσει ή να ανακτήσει αυτό το Aggregate στη μνήμη;
Μπορεί το Order να αποτελεί Aggregate στο Domain και η λίστα παραγγελιών να διαβάζει μόνο DTOs.
Η ύπαρξη του Aggregate στο μοντέλο δεν επιβάλλει τη φόρτωσή του σε κάθε read.
Τα παραδείγματα που ακολουθούν χρησιμοποιούν C# και EF Core. Οι παρατηρήσεις για execution plans και stored procedures αναφέρονται στον SQL Server.
Τι είναι το DDD Aggregate
Ας χρησιμοποιήσουμε μια παραγγελία φαγητού:
Order — Παραγγελία και Aggregate Root
└── OrderItem — Γραμμή παραγγελίας
└── ItemExtra — Πρόσθετο γραμμής
Στο συγκεκριμένο μοντέλο, οι γραμμές και τα πρόσθετα ανήκουν στην παραγγελία και αλλάζουν μέσω αυτής.
Το Order προστατεύει, για παράδειγμα, τον κανόνα:
Μόλις ολοκληρωθεί η παραγγελία, δεν επιτρέπεται αλλαγή ούτε στις γραμμές ούτε στα πρόσθετά τους.
Αυτός ο κανόνας συνδέει επιχειρησιακά τις οντότητες. Η προσθήκη ενός προσθέτου πρέπει να λαμβάνει υπόψη την κατάσταση ολόκληρης της παραγγελίας.
Το Aggregate ορίζει το όριο μέσα στο οποίο διατηρούμε αυτή τη συνέπεια. Το Aggregate Root αποτελεί το σημείο εισόδου για τις αλλαγές. Η ύπαρξη σχέσεων στη βάση, από μόνη της, δεν αρκεί για να ορίσουμε ένα Aggregate.
Για παράδειγμα, μια παραγγελία μπορεί να αναφέρεται σε έναν πελάτη μέσω CustomerId, χωρίς ο πελάτης να αποτελεί μέρος του ίδιου Aggregate.
Περισσότερα: Martin Fowler — DDD Aggregate.
Πότε δικαιολογείται ένα Aggregate
Ξεκινάμε από τους επιχειρησιακούς κανόνες και τις ενέργειες που μπορούν να τους παραβιάσουν.
Στο παράδειγμά μας εξετάζουμε:
- Πρέπει η προσθήκη γραμμής να ελέγχει την κατάσταση της παραγγελίας;
- Πρέπει η προσθήκη προσθέτου να απορρίπτεται όταν η παραγγελία έχει ολοκληρωθεί;
- Πρέπει οι αλλαγές και η ολοκλήρωση να συντονίζονται ώστε να διατηρούνται έγκυρα τα δεδομένα;
- Υπάρχει συμπεριφορά που ανήκει στην παραγγελία και χρειάζεται να συγκεντρωθεί σε ένα σαφές σημείο;
Αυτές οι ανάγκες δικαιολογούν το κοινό όριο στο συγκεκριμένο DDD μοντέλο.
Για απλή αποθήκευση ανεξάρτητων δεδομένων, χωρίς ουσιαστικούς κοινούς κανόνες, μια απλούστερη υλοποίηση CRUD μπορεί να αρκεί.
Ο αριθμός των πινάκων, τα επίπεδα των σχέσεων και το πλήθος των εγγραφών δεν καθορίζουν από μόνα τους αυτή την επιλογή.
Επίσης, 100.000 παραγγελίες σημαίνουν στο συγκεκριμένο μοντέλο 100.000 διαφορετικές περιπτώσεις του Order Aggregate. Η λίστα τους δεν αποτελεί ένα ενιαίο Aggregate.
Περισσότερα: Microsoft — Σχεδιασμός Domain Model.
Πώς λειτουργούν τα writes
Το Create είναι write, όπως και το Update, το Delete και οι ενέργειες που αλλάζουν κατάσταση.
Μπορούμε να έχουμε διαφορετικά endpoints που χρησιμοποιούν το ίδιο Aggregate:
| Ενέργεια | Endpoint | Συμπεριφορά στο Domain |
|---|---|---|
| Δημιουργία | POST /orders |
Νέο Order
|
| Προσθήκη γραμμής | POST /orders/{orderId}/items |
order.AddItem(...) |
| Προσθήκη προσθέτου | POST /orders/{orderId}/items/{itemId}/extras |
order.AddExtra(...) |
| Ολοκλήρωση | POST /orders/{orderId}/complete |
order.Complete() |
Πολλά write endpoints δεν σημαίνουν ανεξάρτητες αλλαγές στα παιδιά του Aggregate. Οι αλλαγές εξακολουθούν να περνούν από το Order.
Create και έγκυρη αρχική κατάσταση
Μια εντολή δημιουργίας μπορεί να περιέχει εξαρχής γραμμή και πρόσθετο. Ο handler χρησιμοποιεί τιμές που έχει επιβεβαιώσει το backend:
var order = new Order(customerId);
// Στο παράδειγμα, η AddItem επιστρέφει το Id της νέας γραμμής.
var itemId = order.AddItem("Πίτσα", 1, trustedItemPrice);
order.AddExtra(itemId, "Έξτρα τυρί", trustedExtraPrice);
dbContext.Orders.Add(order);
await dbContext.SaveChangesAsync(ct);
Οι Domain Methods ελέγχουν, για παράδειγμα, τη θετική ποσότητα και την εγκυρότητα του προσθέτου.
Τα αποσπάσματα δείχνουν τη ροή, παραλείποντας τους πλήρεις ορισμούς των κλάσεων και τους ελέγχους πρόσβασης.
Update και ανάκτηση της απαιτούμενης κατάστασης
Για προσθήκη προσθέτου σε υπάρχουσα γραμμή, το frontend στέλνει μόνο τη συγκεκριμένη εντολή. Δεν χρειάζεται να επιστρέψει ολόκληρη την παραγγελία.
Στο μικρό μας παράδειγμα, για απλότητα φορτώνουμε και τα τρία επίπεδα:
var order = await dbContext.Orders
.AsTracking()
.Include(o => o.Items)
.ThenInclude(i => i.Extras)
.SingleOrDefaultAsync(o => o.Id == orderId, ct)
?? throw new KeyNotFoundException("Order not found.");
order.AddExtra(itemId, extraName, trustedExtraPrice);
await dbContext.SaveChangesAsync(ct);
Η AddExtra του Order ελέγχει ότι η παραγγελία είναι πρόχειρη και ότι η γραμμή υπάρχει. Έπειτα αναθέτει στη γραμμή την ελεγχόμενη προσθήκη του ItemExtra.
Το backend πρέπει να διαθέτει την κατάσταση που απαιτούν οι κανόνες της συγκεκριμένης εντολής. Αυτό δεν συνεπάγεται φόρτωση κάθε σχετιζόμενου αντικειμένου της εφαρμογής.
Η ανάκτηση εδώ εξυπηρετεί ένα write, παρότι ξεκινά με ανάγνωση από τη βάση. Αν χρησιμοποιούμε repository, η φόρτωση μπορεί να βρίσκεται στην υλοποίησή του.
Περισσότερα: Microsoft — Persistence layer και Aggregates.
Ολοκλήρωση και αποθήκευση ανά καρτέλα
Η order.Complete() ελέγχει ότι η παραγγελία μπορεί να ολοκληρωθεί, για παράδειγμα ότι περιέχει γραμμές.
Αν αποθηκεύουμε ανά καρτέλα, δημιουργούμε πρώτα ένα Draft και στέλνουμε ξεχωριστές εντολές για γραμμές και πρόσθετα.
Κάθε request αποθηκεύεται ξεχωριστά. Αν αποτύχει η προσθήκη προσθέτου, οι προηγούμενες επιτυχημένες ενέργειες δεν αναιρούνται.
Αν απαιτείται δημιουργία όλων ή κανενός, μπορούμε να στείλουμε μία τελική εντολή με όσα χρειάζεται η δημιουργία.
Με provider που υποστηρίζει transactions και την προεπιλεγμένη συμπεριφορά του EF Core, οι αλλαγές μιας SaveChangesAsync αποθηκεύονται ατομικά. Αυτό δεν καλύπτει αυτομάτως προηγούμενα requests ούτε τις αρχικές αναγνώσεις του handler.
Περισσότερα: Microsoft — Transactions.
Στοχευμένα reads χωρίς φόρτωση Aggregate
Ο χρήστης μπορεί να χρειάζεται διαφορετικά δεδομένα σε κάθε βήμα:
| Ενέργεια στο UI | Read endpoint |
|---|---|
| Άνοιγμα οθόνης | GET /orders/{orderId}/summary |
| Άνοιγμα καρτέλας προϊόντων | GET /orders/{orderId}/items |
| Ανάπτυξη μιας γραμμής | GET /orders/{orderId}/items/{itemId}/extras |
Έτσι δεν μεταφέρουμε όλα τα πρόσθετα όλων των γραμμών όταν ο χρήστης βλέπει μόνο τη σύνοψη.
Τρία read endpoints μπορούν να εξυπηρετούν δεδομένα ενός Aggregate. Τα όρια του Domain δεν καθορίζονται από τον αριθμό των καρτελών.
Για μια απλή σύνοψη μπορούμε να κάνουμε projection σε DTO:
public sealed record OrderSummaryDto(
Guid Id,
OrderStatus Status);
var summary = await dbContext.Orders
.Where(o => o.Id == orderId)
.Select(o => new OrderSummaryDto(
o.Id,
o.Status))
.SingleOrDefaultAsync(ct);
Δεν χρειάζεται Include για τις γραμμές ή τα πρόσθετα. Η SQL ανακτά τις ζητούμενες τιμές και το EF Core κατασκευάζει το DTO.
Στο συγκεκριμένο projection δεν δημιουργούνται Domain Entities, οπότε δεν υπάρχουν entity instances για να γίνουν tracked.
Αν ένα projection περιλαμβάνει πραγματικές οντότητες, η συμπεριφορά tracking χρειάζεται ξεχωριστή αξιολόγηση.
Περισσότερα: Microsoft — Tracking και projections.
Αυτή η προσέγγιση ταιριάζει σε λίστες, αναζητήσεις, reports και καρτέλες που χρειάζονται μικρό μέρος των δεδομένων.
Ένα read model μπορεί επίσης να συνδυάζει πληροφορίες από περισσότερα Aggregates, μέσα στα επιτρεπόμενα όρια πρόσβασης της εφαρμογής.
Περισσότερα: Microsoft — Reads και Queries σε CQRS.
Τι συμβαίνει σε κάθε αλλαγή σελίδας
Ας υποθέσουμε ότι τα φίλτρα μιας λίστας αντιστοιχούν σε 100.000 παραγγελίες και το UI εμφανίζει 100 ανά σελίδα, δηλαδή 1.000 σελίδες.
Σε κάθε αλλαγή σελίδας, χωρίς πρόσθετο caching:
- Το frontend ζητά τη νέα σελίδα.
- Το backend εκτελεί το αντίστοιχο query.
- Η εφαρμογή επιστρέφει έως 100 DTOs.
Με μέγεθος σελίδας 50 επιστρέφει έως 50.
// pageNumber και pageSize έχουν ήδη ελεγχθεί από το backend.
var page = await dbContext.Orders
.Where(o => o.CustomerId == customerId)
.OrderBy(o => o.Id)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize)
.Select(o => new OrderSummaryDto(
o.Id,
o.Status))
.ToListAsync(ct);
Ο customerId στο παράδειγμα αντιστοιχεί στο επιτρεπόμενο πεδίο πρόσβασης του χρήστη.
Το projection περιορίζει τα πεδία. Το pagination περιορίζει τις εγγραφές.
Το query εκτελείται για τη ζητούμενη σελίδα. Δεν φορτώνουμε πρώτα τις 100.000 παραγγελίες στην εφαρμογή για να διαλέξουμε μετά τις 100.
Περισσότερα: Microsoft — Efficient Querying.
Offset και keyset pagination
Η επιστροφή 100 εγγραφών δεν εγγυάται ότι η βάση επεξεργάζεται μόνο 100.
Στη σελίδα 1.000, το:
.Skip(99900)
.Take(100)
πρέπει να παρακάμψει 99.900 αποτελέσματα. Το κόστος του offset μπορεί να αυξάνεται όσο προχωράμε στις σελίδες.
Για διαδοχική πλοήγηση «επόμενη» και «προηγούμενη», εξετάζουμε keyset pagination: χρησιμοποιούμε τις τιμές ταξινόμησης της τελευταίας εγγραφής για να ζητήσουμε τις επόμενες.
Χρειάζονται κατάλληλα indexes και μοναδική ταξινόμηση. Αν ταξινομούμε κατά ημερομηνία, προσθέτουμε και ένα μοναδικό κριτήριο, όπως το Id.
Η άμεση μετάβαση σε αυθαίρετη σελίδα, όπως η 700, δεν υποστηρίζεται από έναν απλό cursor. Εκεί αξιολογούμε offset ή υβριδική προσέγγιση.
Περισσότερα: Microsoft — Pagination.
Αν το UI χρειάζεται ακριβές συνολικό πλήθος σελίδων, μπορεί να απαιτείται και Count με τα ίδια φίλτρα. Μετράμε και αυτό το κόστος.
Αν χρειάζεται μόνο ένδειξη ότι υπάρχει επόμενη σελίδα, μπορούμε να ζητήσουμε μία επιπλέον εγγραφή.
Τι αλλάζει όταν έχουμε βαθιές σχέσεις
Το σχήμα:
Order → OrderItem → ItemExtra
έχει τρία επίπεδα και δύο σχέσεις. Η ίδια λογική ισχύει αν προστεθεί τέταρτο επίπεδο, δηλαδή βάθος τριών σχέσεων.
Το βάθος δεν αποτελεί από μόνο του λόγο για φόρτωση Aggregate στο read.
Μετράει πόσα δεδομένα χρειάζεται η προβολή. Αν οι 100 παραγγελίες έχουν από 20 γραμμές και κάθε γραμμή από 5 πρόσθετα, η πλήρης απάντηση περιλαμβάνει:
- 100 παραγγελίες.
- 2.000 γραμμές παραγγελιών.
- 10.000 πρόσθετα.
Επομένως, το pageSize = 100 αφορά τις βασικές εγγραφές της λίστας, όχι το συνολικό πλήθος των nested αντικειμένων.
Σε μια σύνοψη επιστρέφουμε τα απαραίτητα πεδία ή μετρήσεις. Τις λεπτομέρειες μπορούμε να τις ζητάμε όταν ανοίγει η αντίστοιχη προβολή.
Αν μια συλλογή παιδιών είναι μεγάλη, μπορεί να χρειάζεται δικό της pagination.
Αν μια σελίδα αντιπροσωπεύει παραγγελίες, το όριο πρέπει να εφαρμόζεται στις σωστές παραγγελίες, αφού ληφθούν υπόψη τα φίλτρα και η ταξινόμηση.
Ένα Take(100) πάνω σε επίπεδες γραμμές ενός JOIN μπορεί να επιστρέψει τμήματα παραγγελιών αντί για 100 παραγγελίες.
Επίσης, ένα HTTP request δεν ισοδυναμεί απαραίτητα με ένα SQL query. Το EF Core μπορεί να φορτώνει σχετιζόμενα δεδομένα με ένα ή περισσότερα queries. Οι επιλογές αυτές έχουν διαφορετικά κόστη και απαιτήσεις συνέπειας.
Περισσότερα: Microsoft — Single και Split Queries.
Πότε είναι λογικό να χρησιμοποιούμε Aggregate και στο read
Η φόρτωση Aggregate για ανάγνωση είναι αποδεκτή επιλογή όταν:
- Το Aggregate είναι μικρό και το κόστος φόρτωσης αποδεκτό.
- Η λειτουργία χρειάζεται το μεγαλύτερο μέρος της κατάστασής του.
- Θέλουμε να χρησιμοποιήσουμε υπάρχουσα Domain συμπεριφορά που υπολογίζει αποτέλεσμα χωρίς να αλλάζει κατάσταση.
- Η επαναχρησιμοποίηση του μοντέλου κρατά την εφαρμογή απλούστερη, χωρίς μετρημένο πρόβλημα απόδοσης.
Αυτά είναι κριτήρια σχεδιασμού, όχι υποχρεωτικός κανόνας του DDD. Ο διαχωρισμός μοντέλων έχει κόστος και δεν ωφελεί κάθε σύστημα.
Περισσότερα: Martin Fowler — CQRS.
Για παράδειγμα, ας υποθέσουμε ότι η οθόνη χρειάζεται ολόκληρη τη μικρή παραγγελία και έναν επιχειρησιακό υπολογισμό που υλοποιείται στην CalculateTotal():
var order = await dbContext.Orders
.AsNoTracking()
.Include(o => o.Items)
.ThenInclude(i => i.Extras)
.SingleOrDefaultAsync(o => o.Id == orderId, ct)
?? throw new KeyNotFoundException("Order not found.");
var total = order.CalculateTotal();
Η CalculateTotal() εδώ είναι καθαρή Domain μέθοδος: διαβάζει την κατάσταση και επιστρέφει αποτέλεσμα χωρίς αλλαγές.
Τέτοιες query methods είναι συμβατές με ένα μοντέλο που περιέχει συμπεριφορά.
Περισσότερα: Martin Fowler — Command Query Separation.
Η επιλογή αυτή μπορεί να αποφεύγει την αντιγραφή σύνθετου επιχειρησιακού υπολογισμού.
Αν χρειαζόμαστε μόνο ένα απλό άθροισμα, ένα SQL projection μπορεί να είναι οικονομικότερο.
Ο handler χαρτογραφεί τα δεδομένα και το αποτέλεσμα σε DTO. Η χρήση Aggregate εσωτερικά δεν σημαίνει ότι το επιστρέφουμε αυτούσιο στο API.
Πότε χρειάζεται SQL aggregation
Το SQL aggregation χρειάζεται όταν το ζητούμενο αποτέλεσμα περιλαμβάνει υπολογισμούς όπως:
- Πλήθος παραγγελιών ανά κατάσταση.
- Συνολική ποσότητα γευμάτων ανά πτήση.
- Συνολική αξία παραγγελιών ανά πελάτη.
- Μέση αξία παραγγελίας ανά ημέρα.
Το κριτήριο είναι ποιο αποτέλεσμα χρειαζόμαστε.
Αν ζητάμε τις παραγγελίες, επιστρέφουμε αναλυτικές εγγραφές με pagination.
Αν ζητάμε πόσες παραγγελίες υπάρχουν σε κάθε κατάσταση, χρησιμοποιούμε ομαδοποίηση και μέτρηση.
var totals = await dbContext.Orders
.Where(o => o.CustomerId == customerId)
.GroupBy(o => o.Status)
.Select(g => new
{
Status = g.Key,
OrderCount = g.Count()
})
.ToListAsync(ct);
Εδώ κάθε αποτέλεσμα αντιπροσωπεύει μία κατάσταση μαζί με το πλήθος των παραγγελιών της.
Δεν χρειάζεται να φορτώσουμε όλα τα Order Aggregates για να υπολογίσουμε τη μέτρηση.
Το query μπορεί να μεταφραστεί σε SQL GROUP BY και COUNT. Ελέγχουμε την παραγόμενη SQL, επειδή η υποστήριξη μετάφρασης εξαρτάται από το query και τον provider.
Περισσότερα: Microsoft — Complex Query Operators.
Το GROUP BY αλλάζει τη μονάδα του αποτελέσματος: επιστρέφει μία γραμμή ανά ομάδα. Δεν αποτελεί γενικό τρόπο επιτάχυνσης κάθε μεγάλης λίστας.
Περισσότερα: Microsoft — SQL GROUP BY.
Aggregation μαζί με pagination
Αν σελιδοποιούμε συγκεντρωτικά αποτελέσματα, η σελίδα αφορά τις τελικές ομάδες.
Για παράδειγμα, αν ζητάμε συνολική ποσότητα γευμάτων ανά πτήση:
- Εφαρμόζουμε τα κατάλληλα φίλτρα.
- Υπολογίζουμε τις ποσότητες ανά πτήση.
- Ταξινομούμε τα συγκεντρωτικά αποτελέσματα.
- Επιστρέφουμε τη ζητούμενη σελίδα.
Αν περιορίσουμε πρώτα αυθαίρετα τις αρχικές εγγραφές στις 100 και μετά υπολογίσουμε τα σύνολα, θα υπολογίσουμε διαφορετικό αποτέλεσμα.
Επίσης, αν ταξινομούμε κατά SUM ή COUNT, η βάση μπορεί να χρειάζεται να υπολογίσει πολλές ομάδες πριν επιλέξει τη σελίδα.
Το keyset pagination δεν εξαφανίζει αυτομάτως αυτό το κόστος.
Περισσότερα: Microsoft — Επεξεργασία SELECT.
Πότε χρησιμοποιούμε stored procedure για reads
Μια stored procedure μπορεί κανονικά να εξυπηρετεί reads.
Την εξετάζουμε όταν προσφέρει συγκεκριμένο όφελος, όπως:
- Οργάνωση πολλών SQL βημάτων σε μία διαδικασία.
- Επαναχρησιμοποίηση συγκεκριμένης λειτουργίας από περισσότερους καταναλωτές.
- Ελεγχόμενη πρόσβαση μέσω δικαιωμάτων εκτέλεσης.
- Υλοποίηση ενός σύνθετου read που έχει αποδειχθεί καταλληλότερη για τις απαιτήσεις μας.
Περισσότερα: Microsoft — Stored procedures.
Η μεταφορά του ίδιου αργού SELECT σε procedure δεν εγγυάται βελτίωση απόδοσης. Ο SQL Server επαναχρησιμοποιεί execution plans και για παραμετροποιημένα queries.
Αν το κόστος προέρχεται από μεγάλο scan, sort ή aggregation, χρειάζεται να αντιμετωπίσουμε αυτή την αιτία.
Περισσότερα: Microsoft — Query processing και plan reuse.
Πώς κρίνουμε αν ένα read χρειάζεται βελτιστοποίηση
Δεν υπάρχει καθολικό όριο όπως «τρία JOINs», «100.000 εγγραφές» ή «1.000 σελίδες» που να επιβάλλει Aggregate ή stored procedure.
Ορίζουμε αποδεκτό χρόνο απόκρισης για τη συγκεκριμένη λειτουργία και μετράμε με αντιπροσωπευτικά δεδομένα και ταυτόχρονο φορτίο.
Για τη λίστα των 1.000 σελίδων ελέγχουμε την πρώτη, μια μεσαία και την τελευταία σελίδα, καθώς και το Count αν χρησιμοποιείται.
Εξετάζουμε το actual execution plan, CPU, logical reads και αναμονές.
Αυτά μας βοηθούν να εντοπίσουμε αν το πρόβλημα βρίσκεται στα indexes, στη σελιδοποίηση, στην παραγόμενη SQL ή σε κάποιο άλλο σημείο.
Περισσότερα: Microsoft — Διάγνωση αργών queries.
Αν το ίδιο ακριβό report υπολογίζεται συχνά, μπορεί να αξίζει ένα προϋπολογισμένο read model.
Αυτό προσθέτει κόστος ενημέρωσης και απαιτεί σαφή απόφαση για το πόσο πρόσφατα πρέπει να είναι τα αποτελέσματα.
Περισσότερα: Microsoft — Materialized View pattern.
Πλήρης κατάσταση και ταυτόχρονες αλλαγές
Ένας Domain υπολογισμός που χρησιμοποιεί όλες τις γραμμές και τα πρόσθετα απαιτεί πλήρη σχετική κατάσταση.
Μία σελίδα γραμμών δεν μπορεί να αντιμετωπίζεται σαν ολόκληρη παραγγελία.
Παράλληλα, χρειάζονται έλεγχοι πρόσβασης σε κάθε endpoint.
Αν ένα read εμφανίζει ότι επιτρέπεται μια ενέργεια, το write πρέπει να την ελέγχει ξανά, επειδή η κατάσταση μπορεί να έχει αλλάξει στο μεταξύ.
Το Aggregate επίσης δεν αντικαθιστά την προστασία από ταυτόχρονες αλλαγές.
Αν ένας χρήστης ολοκληρώνει την παραγγελία ενώ κάποιος άλλος προσθέτει ένα πρόσθετο, ο έλεγχος της κατάστασης μόνο στη μνήμη δεν αρκεί.
Χρειάζεται στρατηγική concurrency που να συντονίζει αυτές τις ενέργειες.
Επειδή το rowversion αφορά συγκεκριμένη εγγραφή, ένα τέτοιο token μόνο στο Root δεν καλύπτει αυτομάτως αλλαγές αποκλειστικά σε child rows.
Περισσότερα: Microsoft — Handling Concurrency Conflicts.
Πρακτικός πίνακας επιλογής
| Ανάγκη | Συνήθης αφετηρία | Γιατί |
|---|---|---|
| Δημιουργία ή αλλαγή με κοινούς Domain κανόνες | Aggregate Root | Συγκεντρώνει τους ελέγχους και τις επιτρεπόμενες αλλαγές |
| Απλό CRUD χωρίς ουσιαστικούς κοινούς κανόνες | Απλή υλοποίηση CRUD | Κρατά την πολυπλοκότητα ανάλογη της ανάγκης |
| Σύνοψη, λίστα ή αναζήτηση | DTO projection | Ανακτά τα πεδία που χρειάζεται η προβολή |
| Μεγάλη λίστα με 50 ή 100 εγγραφές ανά σελίδα | Projection και pagination στη βάση | Περιορίζει τα δεδομένα ανά αίτημα |
| Καρτέλες και λεπτομέρειες που ανοίγουν σταδιακά | Στοχευμένα read endpoints | Αποφεύγει τη μεταφορά δεδομένων που ίσως δεν ζητηθούν |
| Μικρό Aggregate με χρήσιμη καθαρή Domain συμπεριφορά | Φόρτωση Aggregate και mapping σε DTO | Επαναχρησιμοποιεί υπάρχοντες κανόνες με αποδεκτό κόστος |
| Πλήθη, αθροίσματα ή άλλες συγκεντρωτικές τιμές | SQL aggregation | Υπολογίζει το ζητούμενο συγκεντρωτικό αποτέλεσμα |
| Όλα τα δεδομένα χρειάζονται αμέσως | Ενιαίο DTO response | Περιορίζει τα HTTP requests, χωρίς να επιβάλλει φόρτωση Aggregate |
| Σύνθετο read με συγκεκριμένο όφελος από SQL διαδικασία | Αξιολόγηση stored procedure | Οργανώνει τα απαιτούμενα βήματα ή βελτιώνει μετρημένα τη λειτουργία |
| Συχνό και ακριβό συγκεντρωτικό report | Αξιολόγηση προϋπολογισμένου read model | Επαναχρησιμοποιεί υπολογισμένα αποτελέσματα με αποδεκτή καθυστέρηση ενημέρωσης |
Top comments (0)