Your SlideShare is downloading. ×
  • Like
  • Save
CQRS In An Hour Or So
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply

CQRS In An Hour Or So

  • 2,921 views
Published

Presentation by John Nuechterlein (a.k.a. Jdn) for the Chicago ALT.NET user group on January 2010.

Presentation by John Nuechterlein (a.k.a. Jdn) for the Chicago ALT.NET user group on January 2010.

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
No Downloads

Views

Total Views
2,921
On SlideShare
0
From Embeds
0
Number of Embeds
2

Actions

Shares
Downloads
0
Comments
0
Likes
4

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. CQRS in an hour or so
    1
  • 2. Who is jdn?
    Me, aka John Nuechterlein
    Blog: http://www.blogcoward.com
    Operations Manager – Developer – Architect -Raging Douchebag
    eCom then Finance hopefully ecom again background
    Ph.D. in Philosophy (University of Miami at the age of 25)
    HI JEREMY!!!!!!!
    2
  • 3. Sources
    Greg Young
    http://codebetter.com/blogs/gregyoung/archive/2009/08/13/command-query-separation.aspx
    UdiDahan
    http://www.udidahan.com/2009/12/09/clarified-cqrs/
    Mark Nijhof
    http://elegantcode.com/2009/11/11/cqrs-la-greg-young/
    3
  • 4. CQRS
    CQRS = “Command Query Responsibility Segregation”
    Huh?
    A design – pattern -architecture – Framework – Principle – Something
    Makes stuff better
    Huh?
    4
  • 5. CQS Defined
    Bertrand Meyer (via Wikipedia)
    “Command Query Separation”
    “every method should either be a command that performs an action, or a query that returns data to the caller, but not both. In other words, asking a question should not change the answer.”
    5
  • 6. CQRS defined
    Meyer:    Separate command methods that change state from query methods that read state.
    Greg Young:    Separate command messages that change state from query messages that read state.
    Can have significant architectural implications
    6
  • 7. Nihjof #1
    7
  • 8. Nihjof #2
    8
  • 9. Nihjof Categories
    1 – Queries
    2 – Commands
    3 – Internal Events
    4 – External Events
    9
  • 10. UDI #1
    10
  • 11. Queries
    ‘Reporting’
    Misleading description (Greg’s fault), but makes some sense
    Simple Query Layer
    Simple views or sprocs or selects from denormalized tables
    Simple DTOs, no mapping needed
    Don’t go through the Domain Model, as it pollutes it
    ViewModel per query perhaps
    Why should the data come across 5 layers through 3 model transformations to populate a screen? (Udi)
    ‘Traditional Reporting’
    Can (almost always will) have its own Model as well (and perhaps/probably its own data source)
    Synchronous, no messaging needed
    Eventual Consistency (more later)
    11
  • 12. Queries
    No mapping code, don’t even bother getting a domain object at all, e.g.:
    public class ModelDetailBrickDTOMapper : IMapper<Model, ModelDetailBrickDTO>
    {
    public ModelDetailBrickDTO Map(Model m)
    {
    return new ModelDetailBrickDTO(m.ID, m.Name, m.Description, m.Details, m.ShippingMessage, m.GetPrice("Current"), m.GetPrice("MSRP"), m.Sizes, m.Images, DisplayProductBrick.GetRelatedDisplayProductBricksByModel(m));
    }
    }
    12
  • 13. Queries
    Data store
    Cache it (it’s already stale)
    Why not on web-tier?
    Why relational?
    Horizontal scalability
    If you cache, add a new server to handle it
    13
  • 14. Commands
    Commands capture intent, DTOs don’t
    CustomerDTOvsCustomerChangedAddressCommand
    Part of the ‘Ubiquitous’ Language
    Handler per command
    Can be validated outside of domain entities
    This is why no getters/setters on domain entities, their state is updated by processing commands according to the rules of the business
    This is why domain entities are never invalid, commands that would produce invalid state are rejected
    14
  • 15. Commands
    Separate Data Modification
    Make preferred
    Change address
    Delinquent payment event example
    Comes in 1 ms after make preferred event
    What to do?
    A generic DTO could do these things, of course, but after the fact, how do you know what actually happened?
    UI Implications
    Excel-like screens don’t work
    Commands require specific intent
    15
  • 16. Commands
    Commands can be queued
    Split into separate queues
    Scale where needed
    Commands don’t have to be handled by the domain
    16
  • 17. Internal Events
    Triggered by commands
    Can be persisted
    Could be RDBMS, ODBMS, Document DB, etc.
    Event sourcing (big topic, punting)
    Can be replayed
    Production support benefit
    Snapshots can also be created & persisted
    Don’t delete original events
    Domain can accept command or reject it
    Raise event either way
    17
  • 18. Internal Events
    Write-only
    “Accountants don’t use erasers”
    Compensating Actions/Events
    Instead of rolling back a transaction, you compensate for some failure
    Automatic audit log
    You have all the events that happened
    No more ‘impedence mismatch’
    You are persisting events, not rows
    Data mining
    Like I said, you have all the events that happened
    18
  • 19. External Events
    Publishing
    Typically, message bus
    Could use views or ETL to process in a ‘simpler’ architecture
    Data stores can subscribe
    Only process when a read request comes in (GY)
    19
  • 20. External Events
    Publishing external events and persisting internal events done in a transaction
    Eventual Consistency
    Latency is almost always okay
    Question is, how much?
    Availability trumps correctness
    Acting on incomplete data is normal
    Event handler per view model, perhaps
    20
  • 21. Why not CQRS?
    It’s new, it’s different, I’m stupid
    Multiple data stores
    Operational Complexity
    Losing ACID/Transactions is scary
    Lots of Commands and Events and Handlers and Lions and Tigers and Bears oh my! to Code
    21
  • 22. Questions?
    22