Active Record Patterns

Validations

Apply validations to enforce data integrity at the model layer:

• Presence/uniqueness — validates :email, presence: true, uniqueness: true
• Format — format: { with: /pattern/ }
• Numericality — numericality: { greater_than: 0 }
• Length — length: { minimum: 5, maximum: 200 }
• Conditional — if: / unless: with method or lambda
• Custom — validate :method_name for complex rules
• Contexts — on: :create or custom contexts like on: :registration

For detailed examples of each validation type, custom validator classes, and a complete options reference, consult references/validations.md.

Scopes

Define reusable query fragments as scopes. Scopes always return an ActiveRecord::Relation, making them chainable:

class Post < ApplicationRecord
  scope :published, -> { where(published: true) }
  scope :recent, -> { order(created_at: :desc) }
  scope :by_author, ->(user) { where(user: user) }
end

# Chain scopes together
Post.published.recent.by_author(current_user).limit(10)

Prefer scopes over class methods for simple query conditions.

Query Optimization

Preventing N+1 Queries

Key Techniques

• Select specific columns — User.select(:id, :name) or pluck(:email)
• Batch processing — find_each / in_batches for large datasets
• Bulk operations — insert_all / upsert_all for mass writes (skip callbacks)
• Counter caches — belongs_to :user, counter_cache: true to avoid COUNT queries
• Subqueries — User.where(id: Post.published.select(:user_id))
• Existence checks — User.where(email: value).exists? (stops at first match)

For full code examples of all query patterns, consult references/query-patterns.md.

Callbacks

Use callbacks sparingly — only for model-centric operations:

class User < ApplicationRecord
  before_validation :normalize_email
  before_save :encrypt_password, if: :password_changed?
  after_create :send_welcome_email
  after_destroy :cleanup_associated_files
end

Callback order: before_validation → after_validation → before_save → before_create/before_update → after_create/after_update → after_save → after_commit/after_rollback

Avoid callbacks for:

• External API calls (use background jobs)
• Complex business logic (use service objects)
• Sending emails (use background jobs)
• Audit logging (consider after_commit or a dedicated gem)

Model Organization

Organize model code in a consistent order:

class User < ApplicationRecord
  # 1. Includes and extends
  include Searchable

  # 2. Constants
  ROLES = %w[admin member guest].freeze

  # 3. Associations
  has_many :posts, dependent: :destroy
  has_one :profile, dependent: :destroy

  # 4. Validations
  validates :email, presence: true, uniqueness: true

  # 5. Scopes
  scope :active, -> { where(active: true) }

  # 6. Callbacks
  before_save :normalize_email

  # 7. Class methods
  def self.find_by_credentials(email, password)
    find_by(email: email)&.authenticate(password)
  end

  # 8. Instance methods
  def full_name
    "#{first_name} #{last_name}"
  end

  # 9. Private methods
  private

  def normalize_email
    self.email = email.downcase.strip
  end
end

Quick Reference

Additional Resources

Reference Files

For detailed patterns and code examples, consult:

• references/associations.md — Association types, dependent options, polymorphic, delegated types
• references/validations.md — Validation patterns, custom validators, contexts, options reference
• references/query-patterns.md — N+1 prevention, scopes, batching, bulk operations, counter caches