&gt; I believe the DBMS&#x27;s model shouldn&#x27;t be conflated with the application&#x27;s model. Sometimes the row is an entity in the domain; however consider a normalised data structure, where the entity as the application understands it may span a couple of tables.<p>If the right DB structure spans a couple of tables, then it probably shouldn&#x27;t be one monolithic object in an application model (there might be a &quot;central&quot; object of sorts, with other related objects of which it is composed; that doesn&#x27;t mean the models are <i>identical</i>, or even exactly 1:1, as, e.g., aggregates are sensibly single objects in an OO design, but multiple rows with some common attribute in a relational design for the same domain model, but Active Record generally accommodates that.)<p>&gt; DataMappers also shine when working against a legacy database or one that cannot be changed.<p>I generally prefer Data Mapper as a pattern for a variety of reasons (just not the particular ones that were raised as problems with AR upthread, or, at least, for reasons that seem different to me than how those were phrased) -- even though I find that there is a usually a close correspondence between the natural relational model for a domain and the natural OO model, with divergences in models usually indicating a violation of good design principles on one side or the other (often the SRP on the OO side), I find AR <i>itself</i> is a violation of the SRP principle; the description of the pattern in PofEAA should raise a big red warning flag about this: &quot;Each <i>Active Record</i> is responsible for saving and loading to the database and also for any domain logic that acts on the data&quot; --&quot;saving and loading to the database&quot; can credibly seen as one responsibility (more succinctly, persistence) but that &quot;and also&quot; introduces a completely separate responsibility.<p>I also don&#x27;t like that the simplicity of most AR implementations -- the main benefit they seem to offer for that compromise of the SRP -- tends to rest on making additional compromises, mostly in DB design and use, but sometimes on the OO side. If you avoid those compromises, you end up with something that isn&#x27;t any simpler to set up and maintain than a Data Mapper, and Data Mapper gives you more freedom to evolve the persistence implementation independently (even if the <i>model</i> is still usually closely parallel to the application model), and even use different types of datastores.<p>(On a note that <i>does</i> approach one of the issues raised upthread, its also a fact that real world DBs and OOPLs both often require pragmatic compromises to the natural abstract relational or OO models for a domain to optimally address real problems; while it would be ideal to choose better tools -- or improve the tools -- to avoid these problems, that&#x27;s often not a practical option, and tightly coupling application and relational models means that that compromise you choose on one side gets reflected on the other side, where it may not be necessary, and may be counterproductive.)