DEV Community

Cover image for Aggregates στο DDD: πότε στα reads και πότε στα writes με C# και .NET
nikosst
nikosst

Posted on Edited on

Aggregates στο DDD: πότε στα reads και πότε στα writes με C# και .NET

Πότε χρειάζονται 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

Πριν επιλέξουμε υλοποίηση, ξεχωρίζουμε δύο ερωτήσεις:

  1. Χρειάζεται το Domain ένα Aggregate για τους κανόνες του;
  2. Χρειάζεται η συγκεκριμένη λειτουργία να δημιουργήσει ή να ανακτήσει αυτό το Aggregate στη μνήμη;

Μπορεί το Order να αποτελεί Aggregate στο Domain και η λίστα παραγγελιών να διαβάζει μόνο DTOs.

Η ύπαρξη του Aggregate στο μοντέλο δεν επιβάλλει τη φόρτωσή του σε κάθε read.

Τα παραδείγματα που ακολουθούν χρησιμοποιούν C# και EF Core. Οι παρατηρήσεις για execution plans και stored procedures αναφέρονται στον SQL Server.

Τι είναι το DDD Aggregate

Ας χρησιμοποιήσουμε μια παραγγελία φαγητού:

Order — Παραγγελία και Aggregate Root
└── OrderItem — Γραμμή παραγγελίας
    └── ItemExtra — Πρόσθετο γραμμής
Enter fullscreen mode Exit fullscreen mode

Στο συγκεκριμένο μοντέλο, οι γραμμές και τα πρόσθετα ανήκουν στην παραγγελία και αλλάζουν μέσω αυτής.

Το 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);
Enter fullscreen mode Exit fullscreen mode

Οι 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);
Enter fullscreen mode Exit fullscreen mode

Η 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);
Enter fullscreen mode Exit fullscreen mode

Δεν χρειάζεται 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:

  1. Το frontend ζητά τη νέα σελίδα.
  2. Το backend εκτελεί το αντίστοιχο query.
  3. Η εφαρμογή επιστρέφει έως 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);
Enter fullscreen mode Exit fullscreen mode

Ο customerId στο παράδειγμα αντιστοιχεί στο επιτρεπόμενο πεδίο πρόσβασης του χρήστη.

Το projection περιορίζει τα πεδία. Το pagination περιορίζει τις εγγραφές.

Το query εκτελείται για τη ζητούμενη σελίδα. Δεν φορτώνουμε πρώτα τις 100.000 παραγγελίες στην εφαρμογή για να διαλέξουμε μετά τις 100.

Περισσότερα: Microsoft — Efficient Querying.

Offset και keyset pagination

Η επιστροφή 100 εγγραφών δεν εγγυάται ότι η βάση επεξεργάζεται μόνο 100.

Στη σελίδα 1.000, το:

.Skip(99900)
.Take(100)
Enter fullscreen mode Exit fullscreen mode

πρέπει να παρακάμψει 99.900 αποτελέσματα. Το κόστος του offset μπορεί να αυξάνεται όσο προχωράμε στις σελίδες.

Για διαδοχική πλοήγηση «επόμενη» και «προηγούμενη», εξετάζουμε keyset pagination: χρησιμοποιούμε τις τιμές ταξινόμησης της τελευταίας εγγραφής για να ζητήσουμε τις επόμενες.

Χρειάζονται κατάλληλα indexes και μοναδική ταξινόμηση. Αν ταξινομούμε κατά ημερομηνία, προσθέτουμε και ένα μοναδικό κριτήριο, όπως το Id.

Η άμεση μετάβαση σε αυθαίρετη σελίδα, όπως η 700, δεν υποστηρίζεται από έναν απλό cursor. Εκεί αξιολογούμε offset ή υβριδική προσέγγιση.

Περισσότερα: Microsoft — Pagination.

Αν το UI χρειάζεται ακριβές συνολικό πλήθος σελίδων, μπορεί να απαιτείται και Count με τα ίδια φίλτρα. Μετράμε και αυτό το κόστος.

Αν χρειάζεται μόνο ένδειξη ότι υπάρχει επόμενη σελίδα, μπορούμε να ζητήσουμε μία επιπλέον εγγραφή.

Τι αλλάζει όταν έχουμε βαθιές σχέσεις

Το σχήμα:

Order → OrderItem → ItemExtra
Enter fullscreen mode Exit fullscreen mode

έχει τρία επίπεδα και δύο σχέσεις. Η ίδια λογική ισχύει αν προστεθεί τέταρτο επίπεδο, δηλαδή βάθος τριών σχέσεων.

Το βάθος δεν αποτελεί από μόνο του λόγο για φόρτωση 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();
Enter fullscreen mode Exit fullscreen mode

Η 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);
Enter fullscreen mode Exit fullscreen mode

Εδώ κάθε αποτέλεσμα αντιπροσωπεύει μία κατάσταση μαζί με το πλήθος των παραγγελιών της.

Δεν χρειάζεται να φορτώσουμε όλα τα Order Aggregates για να υπολογίσουμε τη μέτρηση.

Το query μπορεί να μεταφραστεί σε SQL GROUP BY και COUNT. Ελέγχουμε την παραγόμενη SQL, επειδή η υποστήριξη μετάφρασης εξαρτάται από το query και τον provider.

Περισσότερα: Microsoft — Complex Query Operators.

Το GROUP BY αλλάζει τη μονάδα του αποτελέσματος: επιστρέφει μία γραμμή ανά ομάδα. Δεν αποτελεί γενικό τρόπο επιτάχυνσης κάθε μεγάλης λίστας.

Περισσότερα: Microsoft — SQL GROUP BY.

Aggregation μαζί με pagination

Αν σελιδοποιούμε συγκεντρωτικά αποτελέσματα, η σελίδα αφορά τις τελικές ομάδες.

Για παράδειγμα, αν ζητάμε συνολική ποσότητα γευμάτων ανά πτήση:

  1. Εφαρμόζουμε τα κατάλληλα φίλτρα.
  2. Υπολογίζουμε τις ποσότητες ανά πτήση.
  3. Ταξινομούμε τα συγκεντρωτικά αποτελέσματα.
  4. Επιστρέφουμε τη ζητούμενη σελίδα.

Αν περιορίσουμε πρώτα αυθαίρετα τις αρχικές εγγραφές στις 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 Επαναχρησιμοποιεί υπολογισμένα αποτελέσματα με αποδεκτή καθυστέρηση ενημέρωσης

[email protected]

Top comments (0)