Rethinking Data Integrity: Why Domain-driven Design Is Crucial

Too often, developers are unfairly accused of being sloppy astir information integrity. The logic goes: Without nan rigid building of an SQL database, developers will codification impulsively, skipping general creation and viewing it arsenic an obstacle alternatively than a captious measurement successful building reliable systems.

Because of this misperception, galore database administrators (DBAs) judge that nan only measurement to guarantee data quality is to usage relational databases. They deliberation that utilizing a archive database for illustration MongoDB intends they can’t beryllium judge information modeling will beryllium done correctly.

Therefore, DBAs are compelled to predefine and deploy schemas successful their database of prime earlier immoderate exertion tin persist aliases stock data. This besides implies that immoderate improvement successful nan exertion requires DBAs to validate and tally a migration book earlier nan caller merchandise reaches users.

However, developers attraction conscionable arsenic overmuch astir information integrity arsenic DBAs do. They put important effort into nan application’s domain exemplary and debar weakening it by mapping it to a normalized information building that does not bespeak exertion usage cases.

Different Database Models, Different Data Models

Relational and document databases return different approaches to information modeling.

In a document database, you still creation your information model. What changes is wherever and really nan creation happens, aligning intimately pinch nan domain exemplary and nan application’s entree patterns. This is particularly existent successful teams practicing domain‑driven creation (DDD), wherever developers put clip successful knowing domain objects, relationships and usage patterns.

The information exemplary evolves alongside nan improvement process — brainstorming ideas, prototyping, releasing a minimum viable merchandise (MVP) for early feedback and iterating toward a stable, production-ready application.

Relational modeling often starts pinch a normalized creation created earlier nan exertion is afloat understood. This exemplary must past service divers early workloads and unpredictable information distributions. For example, a database schema designed for world package could beryllium utilized by some superior schools and ample universities. This illustrates nan spot of relational databases: nan logical exemplary exposed to applications is nan same, moreover erstwhile nan workloads disagree greatly.

Document modeling, by contrast, is tailored to circumstantial exertion usage. Instead of translating nan domain exemplary into normalized tables, which adds abstraction and hides capacity optimizations, MongoDB stores aggregates straight successful nan measurement they look successful your codification and business logic. Documents bespeak nan business transactions and are stored arsenic contiguous blocks connected disk, keeping nan beingness exemplary aligned pinch nan domain schema and optimized for entree patterns.

Here are immoderate different ways these 2 models compare.

Document Modeling Handles Relationships

Relational databases are often thought to excel astatine “strong relationships” betwixt data, but this is partially because of a misunderstanding of nan sanction — relations refers to mathematical sets of tuples (rows), not to nan connections betwixt them, which are relationships. Normalization really loosens beardown relationships, decoupling entities that are later matched astatine query clip via joins.

In entity-relationship diagrams (ERDs), relationships are shown arsenic elemental one-to-one aliases one-to-many links, implemented via superior and overseas keys. ERDs don’t seizure characteristics specified arsenic nan guidance of navigation aliases ownership betwixt entities. Many-to-many relationships are modeled done subordinate tables, which divided them into 2 one-to-many relationships. The only spot of a narration successful an ERD is to separate one-to-one (direct line) from one-to-many (crow’s foot), and nan information exemplary is nan aforesaid whether nan “many” is simply a fewer aliases billions.

Unified Modeling Language (UML)-class diagrams successful object-oriented design, by comparison, are richer: They person a navigation guidance and separate betwixt association, aggregation, creation and inheritance. In MongoDB, these concepts representation naturally:

• Composition (for instance, an bid and its bid lines) often appears arsenic embedded documents, sharing a life rhythm and preventing partial deletion.
• Aggregation ( a customer and their orders) uses references erstwhile life cycles disagree aliases erstwhile nan genitor ownership is shared.
• Inheritance tin beryllium represented via polymorphism, a conception ERDs don’t straight seizure and workaround pinch nullable columns.

Domain models successful object-oriented applications and MongoDB documents amended reflector real-world relationships. In relational databases, schemas are rigid for entities, while relationships are resolved astatine runtime pinch joins — much for illustration a information intelligence discovering correlations during analysis. SQL’s overseas keys forestall orphaned rows, but they aren’t explicitly referenced erstwhile penning SQL queries. Each query tin specify a different relationship.

Schema Validation Protects Data Integrity

MongoDB is schema-flexible, not schema-less. This characteristic is particularly valuable for early-stage projects — specified arsenic brainstorming, prototyping, aliases building an MVP — because you don’t request to execute Data Definition Language (DDL) statements earlier penning data. The schema resides wrong nan exertion code, and documents are stored as-is, without further validation astatine first, arsenic consistency is ensured by nan aforesaid exertion that writes and sounds them.

As nan exemplary matures, you tin specify schema validation rules straight successful nan database — section requirements, information types, and accepted ranges. You don’t request to state each section immediately. You adhd validation arsenic nan schema matures, becomes stable, and is shared. This ensures accordant building erstwhile aggregate components dangle connected nan aforesaid fields, aliases erstwhile indexing, since only nan fields utilized by nan exertion are adjuvant successful nan index.

Schema elasticity boosts improvement velocity astatine each shape of your application. Early successful prototyping, you tin adhd fields freely without worrying astir contiguous validation. Later, pinch schema validation successful place, you tin trust connected nan database to enforce information integrity, reducing nan request to constitute and support codification that checks incoming data.

Schema validation tin besides enforce beingness bounds. If you embed bid items successful nan bid document, you mightiness validate that nan array does not transcend a definite threshold. Instead of failing outright — for illustration SQL’s cheque constraints (which often origin unhandled exertion errors) — MongoDB tin log a warning, alerting nan squad without disrupting personification operations. This enables nan exertion to enactment disposable while still flagging imaginable anomalies aliases basal evolutions.

Application Logic vs. Foreign Keys

In SQL databases, overseas keys are constraints, not existent definitions of relationships, which are evaluated astatine query time. SQL joins specify relationships by listing columns arsenic select predicates, and overseas keys are not utilized successful nan JOIN clause. Foreign keys thief forestall definite anomalies, specified arsenic orphaned children aliases cascading deletes, that originate from normalization.

MongoDB takes a different approach: By embedding tightly coupled entities, you lick awesome integrity concerns upfront. For example, embedding bid lines wrong their bid archive intends orphaned statement items are intolerable by design. Referential relationships are handled by exertion logic, often reference from unchangeable collections (lists of values) earlier embedding their values into a document.

Because MongoDB models are built for known entree patterns and life cycles, referential integrity is maintained done business rules alternatively than enforced generically. In practice, this amended reflects real-world processes, wherever updates aliases deletions must travel circumstantial conditions (such asa value driblet mightiness use to ongoing orders, but a value summation mightiness not).

In relational databases, nan schema is application-agnostic, truthful you must protect against immoderate imaginable Data Manipulation Language (DML) modifications, not conscionable those that consequence from valid business transactions. Doing truthful successful nan exertion would require other locks aliases higher isolation levels, truthful it’s often much businesslike to state overseas keys for nan database to enforce.

However, erstwhile domain usage cases are good understood, protections are required for only a fewer cases and tin beryllium integrated into nan business logic itself. For example, a merchandise will ne'er beryllium deleted while ongoing transactions are utilizing it. The business workflow often marks nan merchandise arsenic unavailable agelong earlier it is physically deleted, and transactions are short-lived capable that there’s nary overlap, preventing orphans without further checks.

In domain‑driven models, wherever nan schema is designed astir circumstantial exertion usage cases, integrity tin beryllium afloat managed by nan exertion squad alongside nan business rules. While further database verification whitethorn service arsenic a safeguard, it could limit scalability, peculiarly pinch sharding, and limit flexibility. An replacement is to tally a periodic aggregation pipeline that asynchronously detects anomalies.

Next Time You Hear That Myth

MongoDB does not mean “no design.” It intends integrating database creation pinch exertion creation — embedding, referencing, schema validation and application‑level integrity checks to bespeak existent domain semantics.

This attack keeps information modeling a first‑class interest for developers, aligning straight pinch nan measurement domain objects are represented successful code. The database building evolves alongside nan application, and integrity is enforced successful nan aforesaid connection and pipelines that present nan exertion itself.

In environments wherever DBAs only spot nan database exemplary and SQL operations, overseas keys whitethorn look indispensable. But successful a DevOps workflow wherever nan aforesaid squad handles some nan database and nan application, schema rules tin beryllium implemented first successful codification and refined successful nan database arsenic specifications stabilize. This avoids maintaining 2 abstracted models and nan associated migration overhead, enabling faster, iterative releases while preserving integrity.

Group Created pinch Sketch.