ActiveRecord vs DataMapper Pattern: Internals, Trade-offs and When Each One Breaks

# Gemfile dependency: gem 'activerecord', gem 'sqlite3'
require 'active_record'

# Connect to an in-memory SQLite database — great for demos and tests
ActiveRecord::Base.establish_connection(
  adapter:  'sqlite3',
  database: ':memory:'
)

# Define the schema inline — in a real app this lives in db/migrate/
ActiveRecord::Schema.define do
  create_table :employees do |t|
    t.string  :full_name,   null: false
    t.string  :department,  null: false
    t.decimal :salary,      precision: 10, scale: 2, null: false
    t.boolean :active,      default: true
    t.timestamps
  end
end

# The model class maps 1-to-1 with the 'employees' table.
# Notice: NO explicit column definitions. AR reads the schema at runtime.
class Employee < ActiveRecord::Base
  # Business logic lives right here alongside persistence
  validates :full_name, presence: true
  validates :salary,    numericality: { greater_than: 0 }

  # A domain method — but it triggers a DB query internally
  def senior?
    salary > 90_000
  end

  # A scope compiles to SQL lazily — nothing runs until you enumerate
  scope :active_staff,  -> { where(active: true) }
  scope :in_department, ->(dept) { where(department: dept) }
end

# --- Demonstrate the pattern ---

# INSERT: AR builds and executes the SQL, sets id and timestamps automatically
engineering_lead = Employee.create!(
  full_name:  'Priya Kapoor',
  department: 'Engineering',
  salary:     112_000.00
)
puts "Created: #{engineering_lead.full_name} (id=#{engineering_lead.id})"

Employee.create!(full_name: 'Marcus Webb',   department: 'Engineering', salary: 78_000.00)
Employee.create!(full_name: 'Sofia Alvarez', department: 'Marketing',   salary: 95_000.00)

# SELECT with scope chaining — SQL is built lazily, fired once
senior_engineers = Employee.active_staff.in_department('Engineering').select(&:senior?)
# NOTE: .select(&:senior?) is Ruby enumerable filter, runs AFTER the DB query.
# For large datasets, push that filter into the SQL with a where clause instead.

senior_engineers.each do |emp|
  puts "Senior engineer: #{emp.full_name} — $#{emp.salary}"
end

# UPDATE: AR tracks 'dirty' attributes and only updates changed columns
engineering_lead.salary = 118_000.00
engineering_lead.save!
puts "Updated salary. Changed fields were: #{engineering_lead.saved_changes.keys}"

# The object IS the row — you can check persistence state directly
puts "Persisted? #{engineering_lead.persisted?}"  # => true
puts "New record? #{engineering_lead.new_record?}" # => false

# Pure DataMapper pattern in Python — no ORM framework needed to understand it.
# Dependencies: pip install sqlalchemy
from dataclasses import dataclass, field
from typing import List, Optional
import sqlalchemy as sa
from sqlalchemy import create_engine, Table, Column, Integer, String, Numeric, Boolean, MetaData

# ─────────────────────────────────────────────
# LAYER 1: Domain Object — knows NOTHING about SQL or tables.
# This is a plain Python dataclass. You can unit-test every method
# here without touching a database at all.
# ─────────────────────────────────────────────
@dataclass
class Employee:
    full_name:  str
    department: str
    salary:     float
    active:     bool  = True
    id:         Optional[int] = field(default=None, repr=False)

    # Pure domain logic — no DB dependency whatsoever
    def is_senior(self) -> bool:
        return self.salary > 90_000

    def apply_annual_raise(self, percentage: float) -> None:
        """Apply a raise and validate the business rule inline."""
        if percentage <= 0 or percentage > 0.25:
            raise ValueError(f"Raise of {percentage:.0%} is outside policy limits (0–25%).")
        self.salary = round(self.salary * (1 + percentage), 2)


# ─────────────────────────────────────────────
# LAYER 2: Database Schema — lives in the mapper layer, not the domain.
# The domain object Employee has no idea this table definition exists.
# ─────────────────────────────────────────────
engine   = create_engine('sqlite:///:memory:', echo=False)
metadata = MetaData()

employees_table = Table(
    'employees', metadata,
    Column('id',          Integer,        primary_key=True, autoincrement=True),
    Column('full_name',   String(120),    nullable=False),
    Column('department',  String(80),     nullable=False),
    Column('salary',      Numeric(10, 2), nullable=False),
    Column('active',      Boolean(),      default=True),
)
metadata.create_all(engine)


# ─────────────────────────────────────────────
# LAYER 3: The Mapper — translates between domain objects and rows.
# This is the heart of the DataMapper pattern.
# Swap this class out for a REST adapter and Employee never changes.
# ─────────────────────────────────────────────
class EmployeeMapper:
    def __init__(self, db_engine: sa.engine.Engine):
        self._engine = db_engine

    def _row_to_domain(self, row) -> Employee:
        """Translate a raw database row into a rich domain object."""
        return Employee(
            id         = row.id,
            full_name  = row.full_name,
            department = row.department,
            salary     = float(row.salary),
            active     = row.active,
        )

    def save(self, employee: Employee) -> Employee:
        """INSERT or UPDATE depending on whether the employee has an id."""
        with self._engine.begin() as conn:
            if employee.id is None:
                # New employee — INSERT and capture the auto-generated id
                result = conn.execute(
                    employees_table.insert().values(
                        full_name  = employee.full_name,
                        department = employee.department,
                        salary     = employee.salary,
                        active     = employee.active,
                    )
                )
                employee.id = result.inserted_primary_key[0]  # Assign PK back to domain obj
            else:
                # Existing employee — UPDATE only the mutable columns
                conn.execute(
                    employees_table.update()
                    .where(employees_table.c.id == employee.id)
                    .values(salary=employee.salary, active=employee.active)
                )
        return employee

    def find_by_id(self, employee_id: int) -> Optional[Employee]:
        with self._engine.connect() as conn:
            row = conn.execute(
                employees_table.select()
                .where(employees_table.c.id == employee_id)
            ).fetchone()
            return self._row_to_domain(row) if row else None

    def find_by_department(self, department: str) -> List[Employee]:
        with self._engine.connect() as conn:
            rows = conn.execute(
                employees_table.select()
                .where(employees_table.c.department == department)
                .where(employees_table.c.active == True)
            ).fetchall()
            return [self._row_to_domain(r) for r in rows]


# ─────────────────────────────────────────────
# USAGE — notice how clean the application code reads.
# The caller works only with domain objects and the mapper.
# ─────────────────────────────────────────────
mapper = EmployeeMapper(engine)

# Create domain objects first — no DB touch yet
priya  = Employee(full_name='Priya Kapoor', department='Engineering', salary=112_000.00)
marcus = Employee(full_name='Marcus Webb',  department='Engineering', salary=78_000.00)

# Persist via the mapper
mapper.save(priya)
mapper.save(marcus)
print(f"Saved Priya with id={priya.id}, Marcus with id={marcus.id}")

# Apply a raise using pure domain logic — ZERO DB calls here
priya.apply_annual_raise(0.05)
print(f"Priya's new salary after 5% raise: ${priya.salary:,.2f}")

# Persist the change — mapper handles the UPDATE
mapper.save(priya)

# Reload from DB and verify
reloaded = mapper.find_by_id(priya.id)
print(f"Reloaded from DB: {reloaded.full_name} — ${reloaded.salary:,.2f} — Senior: {reloaded.is_senior()}")

# Fetch all active engineers
engineers = mapper.find_by_department('Engineering')
for emp in engineers:
    print(f"  Engineer: {emp.full_name} | Senior: {emp.is_senior()}")

require 'active_record'
require 'logger'

ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')

# Suppress most AR logging except the SQL we care about
ActiveRecord::Base.logger = Logger.new($stdout)
ActiveRecord::Base.logger.level = Logger::WARN

ActiveRecord::Schema.define do
  create_table :departments do |t|
    t.string :name, null: false
  end
  create_table :staff_members do |t|
    t.string  :full_name,     null: false
    t.decimal :annual_salary, precision: 10, scale: 2
    t.integer :department_id, null: false
    t.index   :department_id
  end
end

class Department  < ActiveRecord::Base
  has_many :staff_members
end

class StaffMember < ActiveRecord::Base
  belongs_to :department
end

# Seed three departments with two staff each
%w[Engineering Marketing Finance].each do |dept_name|
  dept = Department.create!(name: dept_name)
  2.times do |i|
    StaffMember.create!(
      full_name:     "#{dept_name} Employee #{i + 1}",
      annual_salary: rand(70_000..120_000),
      department_id: dept.id
    )
  end
end

puts "\n=== N+1 PROBLEM: one query per staff member for their department ==="
# This fires 1 query to get all staff + 1 query PER staff member to load department = 7 queries
staff_without_preload = StaffMember.all
staff_without_preload.each do |member|
  # Each .department call here hits the DB unless cached
  puts "  #{member.full_name} works in #{member.department.name}"
end

puts "\n=== FIXED: eager loading collapses to 2 queries total ==="
# .includes tells AR to JOIN or fire a second batched IN() query — your choice
# Use .eager_load for a LEFT OUTER JOIN, .preload for a separate IN() query.
staff_with_preload = StaffMember.includes(:department).all
staff_with_preload.each do |member|
  # .department.name hits the in-memory cache — ZERO additional DB queries
  puts "  #{member.full_name} works in #{member.department.name}"
end

puts "\n=== PROACTIVE APPROACH: use Bullet gem in development ==="
# In a real Rails app, add 'bullet' to your Gemfile under development group:
# config.after_initialize do
#   Bullet.enable        = true
#   Bullet.raise         = true  # raises an exception on N+1 — catches it in CI
#   Bullet.alert         = true
# end
# Bullet will raise Bullet::Notification::UnoptimizedQueryError when N+1 is detected.
puts "  Add gem 'bullet' to Gemfile and set Bullet.raise = true in development.rb"
puts "  This turns N+1 bugs into test failures — catches them before production."

# This shows the Repository pattern — a DataMapper variant that's
# idiomatic in DDD and works beautifully alongside ActiveRecord.
# The repository is the mapper; it returns domain objects (or AR models
# treated as pure data) and owns all query logic.

require 'active_record'

ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')

ActiveRecord::Schema.define do
  create_table :orders do |t|
    t.string  :customer_email, null: false
    t.string  :status,         null: false, default: 'pending'
    t.decimal :total_cents,    precision: 15, scale: 0, null: false
    t.timestamps
  end
  create_table :order_line_items do |t|
    t.integer :order_id,       null: false
    t.string  :product_sku,    null: false
    t.integer :quantity,       null: false
    t.decimal :unit_price_cents, precision: 12, scale: 0, null: false
    t.index   :order_id
  end
end

# AR models used ONLY as thin persistence wrappers — no business logic here
class OrderRecord < ActiveRecord::Base
  self.table_name = 'orders'
  has_many :line_item_records, foreign_key: :order_id
end

class LineItemRecord < ActiveRecord::Base
  self.table_name = 'order_line_items'
  belongs_to :order_record
end

# ── Pure domain objects — zero AR inheritance ──
OrderLineItem = Struct.new(:product_sku, :quantity, :unit_price_cents, keyword_init: true) do
  def subtotal_cents
    quantity * unit_price_cents
  end
end

class Order
  attr_reader :id, :customer_email, :status, :line_items

  def initialize(id:, customer_email:, status:, line_items: [])
    @id             = id
    @customer_email = customer_email
    @status         = status
    @line_items     = line_items
  end

  # Domain logic lives here — testable with no DB
  def total_cents
    line_items.sum(&:subtotal_cents)
  end

  def can_be_cancelled?
    status == 'pending'
  end

  def cancel!
    raise "Order #{id} cannot be cancelled — status is '#{status}'" unless can_be_cancelled?
    @status = 'cancelled'
  end
end

# ── The Repository: this IS the mapper ──
class OrderRepository
  # Persist a new or updated Order domain object
  def save(order)
    record = order.id ? OrderRecord.find(order.id) : OrderRecord.new
    record.customer_email = order.customer_email
    record.status         = order.status
    record.total_cents    = order.total_cents
    record.save!

    # Sync line items — naive replace strategy for clarity
    record.line_item_records.destroy_all
    order.line_items.each do |item|
      record.line_item_records.create!(
        product_sku:      item.product_sku,
        quantity:         item.quantity,
        unit_price_cents: item.unit_price_cents
      )
    end

    rebuild_domain_from(record)  # Always return a fresh domain object
  end

  def find(order_id)
    record = OrderRecord.includes(:line_item_records).find(order_id)
    rebuild_domain_from(record)
  end

  def pending_orders_for(customer_email)
    OrderRecord.includes(:line_item_records)
               .where(customer_email: customer_email, status: 'pending')
               .map { |record| rebuild_domain_from(record) }
  end

  private

  # Centralised translation — one place to change if schema evolves
  def rebuild_domain_from(record)
    items = record.line_item_records.map do |li|
      OrderLineItem.new(
        product_sku:      li.product_sku,
        quantity:         li.quantity,
        unit_price_cents: li.unit_price_cents
      )
    end
    Order.new(
      id:             record.id,
      customer_email: record.customer_email,
      status:         record.status,
      line_items:     items
    )
  end
end

# ── Application code ──
repo = OrderRepository.new

new_order = Order.new(
  id:             nil,
  customer_email: 'priya@example.com',
  status:         'pending',
  line_items:     [
    OrderLineItem.new(product_sku: 'WIDGET-42', quantity: 3, unit_price_cents: 2999),
    OrderLineItem.new(product_sku: 'GADGET-7',  quantity: 1, unit_price_cents: 14999)
  ]
)

saved_order = repo.save(new_order)
puts "Order saved. id=#{saved_order.id}, total=$#{saved_order.total_cents / 100.0}"

# Cancel using pure domain logic — no DB call inside cancel!
saved_order.cancel!
puts "Cancelled? #{saved_order.status} | Can cancel again? #{saved_order.can_be_cancelled?}"

# Persist the state change via repository
updated_order = repo.save(saved_order)
puts "Persisted status: #{updated_order.status}"

# Reload and verify
reloaded = repo.find(updated_order.id)
puts "Reloaded — email: #{reloaded.customer_email}, status: #{reloaded.status}, items: #{reloaded.line_items.length}"