ibm_db 5.6.1-arm64-darwin-24

data/test/models/club.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Club < ActiveRecord::Base
+  has_one :membership, touch: true
+  has_many :memberships, inverse_of: false
+  has_many :members, through: :memberships
+  has_one :sponsor
+  has_one :sponsored_member, through: :sponsor, source: :sponsorable, source_type: :Member
+  belongs_to :category
+
+  has_many :favourites, -> { where(memberships: { favourite: true }) }, through: :memberships, source: :member
+
+  scope :general, -> { left_joins(:category).where(categories: { name: "General" }).unscope(:limit) }
+
+  accepts_nested_attributes_for :membership
+
+  private
+    def private_method
+      "I'm sorry sir, this is a *private* club, not a *pirate* club"
+    end
+end
+
+class SuperClub < ActiveRecord::Base
+  self.table_name = "clubs"
+
+  has_many :memberships, class_name: "SuperMembership", foreign_key: "club_id"
+  has_many :members, through: :memberships
+end

data/test/models/college.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "models/arunit2_model"
+require "active_support/core_ext/object/with_options"
+
+class College < ARUnit2Model
+  has_many :courses
+
+  with_options dependent: :destroy do |assoc|
+    assoc.has_many :students, -> { where(active: true) }
+  end
+end

data/test/models/column.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Column < ActiveRecord::Base
+  belongs_to :record
+end

data/test/models/column_name.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ColumnName < ActiveRecord::Base
+  self.table_name = "colnametests"
+end

data/test/models/comment.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# `counter_cache` requires association class before `attr_readonly`.
+class Post < ActiveRecord::Base; end
+
+class Comment < ActiveRecord::Base
+  scope :limit_by, lambda { |l| limit(l) }
+  scope :containing_the_letter_e, -> { where("comments.body LIKE '%e%'") }
+  scope :not_again, -> { where("comments.body NOT LIKE '%again%'") }
+  scope :for_first_post, -> { where(post_id: 1) }
+  scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
+  scope :created, -> { all }
+
+  belongs_to :post, counter_cache: true
+  belongs_to :author,   polymorphic: true
+  belongs_to :resource, polymorphic: true
+  belongs_to :company, foreign_key: "company"
+
+  has_many :ratings
+
+  belongs_to :first_post, foreign_key: :post_id
+  belongs_to :special_post_with_default_scope, foreign_key: :post_id
+
+  has_many :children, class_name: "Comment", foreign_key: :parent_id, inverse_of: :parent
+  belongs_to :parent, class_name: "Comment", counter_cache: :children_count, inverse_of: :children
+
+  alias_attribute :entry, :post
+
+  enum label: [:default, :child]
+
+  class ::OopsError < RuntimeError; end
+
+  module OopsExtension
+    def destroy_all(*)
+      raise OopsError
+    end
+  end
+
+  default_scope { extending OopsExtension }
+
+  scope :oops_comments, -> { extending OopsExtension }
+
+  # Should not be called if extending modules that having the method exists on an association.
+  def self.greeting
+    raise
+  end
+
+  def self.what_are_you
+    "a comment..."
+  end
+
+  def self.search_by_type(q)
+    where("#{QUOTED_TYPE} = ?", q)
+  end
+
+  def self.all_as_method
+    all
+  end
+  scope :all_as_scope, -> { all }
+
+  def to_s
+    body
+  end
+end
+
+class SpecialComment < Comment
+  has_one :author, through: :post
+  default_scope { where(deleted_at: nil) }
+
+  def self.what_are_you
+    "a special comment..."
+  end
+end
+
+class SubSpecialComment < SpecialComment
+end
+
+class VerySpecialComment < Comment
+end
+
+class CommentThatAutomaticallyAltersPostBody < Comment
+  belongs_to :post, class_name: "PostThatLoadsCommentsInAnAfterSaveHook", foreign_key: :post_id
+
+  after_save do |comment|
+    comment.post.update(body: "Automatically altered")
+  end
+end
+
+class CommentWithDefaultScopeReferencesAssociation < Comment
+  default_scope -> { includes(:developer).order("developers.name").references(:developer) }
+  belongs_to :developer
+end
+
+class CommentWithAfterCreateUpdate < Comment
+  after_create do
+    update(body: "bar")
+  end
+end

data/test/models/company.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+class AbstractCompany < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+class Company < AbstractCompany
+  self.sequence_name = :companies_nonstd_seq
+
+  validates_presence_of :name
+
+  has_one :account, foreign_key: "firm_id"
+  has_one :dummy_account, foreign_key: "firm_id", class_name: "Account"
+  has_many :contracts
+  has_many :developers, through: :contracts
+  has_many :special_contracts, -> { includes(:special_developer).where.not("developers.id": nil) }
+  has_many :special_developers, through: :special_contracts
+  has_many :comments, foreign_key: "company"
+
+  alias_attribute :new_name, :name
+  attribute :metadata, :json
+
+  scope :of_first_firm, lambda {
+    joins(account: :firm).where("companies.id": 1)
+  }
+
+  def arbitrary_method
+    "I am Jack's profound disappointment"
+  end
+
+  private
+    def private_method
+      "I am Jack's innermost fears and aspirations"
+    end
+
+    class SpecialCo < Company
+    end
+end
+
+module Namespaced
+  class Company < ::Company
+  end
+
+  class Firm < ::Company
+    has_many :clients, class_name: "Namespaced::Client"
+  end
+
+  class Client < ::Company
+  end
+end
+
+class Firm < Company
+  to_param :name
+
+  has_many :clients, -> { order "id" }, dependent: :destroy, before_remove: :log_before_remove, after_remove: :log_after_remove
+  has_many :unsorted_clients, class_name: "Client"
+  has_many :unsorted_clients_with_symbol, class_name: :Client
+  has_many :clients_sorted_desc, -> { order "id DESC" }, class_name: "Client"
+  has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", inverse_of: :firm
+  has_many :clients_ordered_by_name, -> { order "name" }, class_name: "Client"
+  has_many :unvalidated_clients_of_firm, foreign_key: "client_of", class_name: "Client", validate: false
+  has_many :dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :destroy
+  has_many :exclusively_dependent_clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :limited_clients, -> { limit 1 }, class_name: "Client"
+  has_many :clients_with_interpolated_conditions, ->(firm) { where "rating > #{firm.rating}" }, class_name: "Client"
+  has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, class_name: "Client"
+  has_many :clients_like_ms_with_hash_conditions, -> { where(name: "Microsoft").order("id") }, class_name: "Client"
+  has_many :plain_clients, class_name: "Client"
+  has_many :clients_using_primary_key, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name"
+  has_many :clients_using_primary_key_with_delete_all, class_name: "Client",
+           primary_key: "name", foreign_key: "firm_name", dependent: :delete_all
+  has_many :clients_grouped_by_firm_id, -> { group("firm_id").select("firm_id") }, class_name: "Client"
+  has_many :clients_grouped_by_name, -> { group("name").select("name") }, class_name: "Client"
+
+  has_one :account, foreign_key: "firm_id", dependent: :destroy, validate: true
+  has_one :unvalidated_account, foreign_key: "firm_id", class_name: "Account", validate: false
+  has_one :account_with_select, -> { select("id, firm_id") }, foreign_key: "firm_id", class_name: "Account"
+  has_one :readonly_account, -> { readonly }, foreign_key: "firm_id", class_name: "Account"
+  # added order by id as in fixtures there are two accounts for Rails Core
+  # Oracle tests were failing because of that as the second fixture was selected
+  has_one :account_using_primary_key, -> { order("id") }, primary_key: "firm_id", class_name: "Account"
+  has_one :account_using_foreign_and_primary_keys, foreign_key: "firm_name", primary_key: "name", class_name: "Account"
+  has_one :account_with_inexistent_foreign_key, class_name: "Account", foreign_key: "inexistent"
+  has_one :deletable_account, foreign_key: "firm_id", class_name: "Account", dependent: :delete
+
+  has_one :account_limit_500_with_hash_conditions, -> { where credit_limit: 500 }, foreign_key: "firm_id", class_name: "Account"
+
+  has_one :unautosaved_account, foreign_key: "firm_id", class_name: "Account", autosave: false
+  has_many :accounts
+  has_many :unautosaved_accounts, foreign_key: "firm_id", class_name: "Account", autosave: false
+
+  has_many :association_with_references, -> { references(:foo) }, class_name: "Client"
+
+  has_many :developers_with_select, -> { select("id, name, first_name") }, class_name: "Developer"
+
+  has_one :lead_developer, class_name: "Developer"
+  has_many :projects
+
+  def log
+    @log ||= []
+  end
+
+  private
+    def log_before_remove(record)
+      log << "before_remove#{record.id}"
+    end
+
+    def log_after_remove(record)
+      log << "after_remove#{record.id}"
+    end
+end
+
+class DependentFirm < Company
+  has_one :account, -> { order(:id) }, foreign_key: "firm_id", dependent: :nullify
+  has_many :companies, foreign_key: "client_of", dependent: :nullify
+  has_one :company, foreign_key: "client_of", dependent: :nullify
+end
+
+class RestrictedWithExceptionFirm < Company
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_exception
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_exception
+end
+
+class RestrictedWithErrorFirm < Company
+  has_one :account, -> { order("id") }, foreign_key: "firm_id", dependent: :restrict_with_error
+  has_many :companies, -> { order("id") }, foreign_key: "client_of", dependent: :restrict_with_error
+end
+
+class Agency < Firm
+  has_many :projects, foreign_key: :firm_id
+
+  accepts_nested_attributes_for :projects
+end
+
+class Client < Company
+  belongs_to :firm, foreign_key: "client_of"
+  belongs_to :firm_with_basic_id, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_select, -> { select("id") }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_condition, -> { where "1 = ?", 1 }, class_name: "Firm", foreign_key: "client_of"
+  belongs_to :firm_with_primary_key, class_name: "Firm", primary_key: "name", foreign_key: "firm_name"
+  belongs_to :firm_with_primary_key_symbols, class_name: "Firm", primary_key: :name, foreign_key: :firm_name
+  belongs_to :readonly_firm, -> { readonly }, class_name: "Firm", foreign_key: "firm_id"
+  belongs_to :bob_firm, -> { where name: "Bob" }, class_name: "Firm", foreign_key: "client_of"
+  has_many :accounts, through: :firm, source: :accounts
+  belongs_to :account
+
+  validate do
+    firm
+  end
+
+  class RaisedOnSave < RuntimeError; end
+  attr_accessor :raise_on_save
+  before_save do
+    raise RaisedOnSave if raise_on_save
+  end
+
+  attr_accessor :throw_on_save
+  before_save do
+    throw :abort if throw_on_save
+  end
+
+  attr_accessor :rollback_on_save
+  after_save do
+    raise ActiveRecord::Rollback if rollback_on_save
+  end
+
+  attr_accessor :rollback_on_create_called
+  after_rollback(on: :create) do |client|
+    client.rollback_on_create_called = true
+  end
+
+  class RaisedOnDestroy < RuntimeError; end
+  attr_accessor :raise_on_destroy
+  before_destroy do
+    raise RaisedOnDestroy if raise_on_destroy
+  end
+
+  # Record destruction so we can test whether firm.clients.clear has
+  # is calling client.destroy, deleting from the database, or setting
+  # foreign keys to NULL.
+  def self.destroyed_client_ids
+    @destroyed_client_ids ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  before_destroy do |client|
+    if client.firm
+      Client.destroyed_client_ids[client.firm.id] << client.id
+    end
+    true
+  end
+
+  before_destroy :overwrite_to_raise
+
+  # Used to test that read and question methods are not generated for these attributes
+  def rating?
+    query_attribute :rating
+  end
+
+  def overwrite_to_raise
+  end
+end
+
+class ExclusivelyDependentFirm < Company
+  has_one :account, foreign_key: "firm_id", dependent: :delete
+  has_many :dependent_sanitized_conditional_clients_of_firm, -> { order("id").where("name = 'BigShot Inc.'") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_hash_conditional_clients_of_firm, -> { order("id").where(name: "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+  has_many :dependent_conditional_clients_of_firm, -> { order("id").where("name = ?", "BigShot Inc.") }, foreign_key: "client_of", class_name: "Client", dependent: :delete_all
+end
+
+class SpecialClient < Client
+end
+
+class VerySpecialClient < SpecialClient
+end
+
+class NewlyContractedCompany < Company
+  has_many :new_contracts, foreign_key: "company_id"
+
+  before_save do
+    self.new_contracts << NewContract.new
+  end
+end
+
+require "models/account"

data/test/models/company_in_module.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/with_options"
+
+module MyApplication
+  module Business
+    class Company < ActiveRecord::Base
+    end
+
+    class Firm < Company
+      has_many :clients, -> { order("id") }, dependent: :destroy
+      has_many :clients_sorted_desc, -> { order("id DESC") }, class_name: "Client"
+      has_many :clients_of_firm, -> { order "id" }, foreign_key: "client_of", class_name: "Client"
+      has_many :clients_like_ms, -> { where("name = 'Microsoft'").order("id") }, class_name: "Client"
+      has_one :account, class_name: "MyApplication::Billing::Account", dependent: :destroy
+    end
+
+    class Client < Company
+      belongs_to :firm, foreign_key: "client_of"
+      belongs_to :firm_with_other_name, class_name: "Firm", foreign_key: "client_of"
+
+      class Contact < ActiveRecord::Base; end
+    end
+
+    class Developer < ActiveRecord::Base
+      has_and_belongs_to_many :projects
+      validates_length_of :name, within: (3..20)
+    end
+
+    class Project < ActiveRecord::Base
+      has_and_belongs_to_many :developers
+    end
+
+    module Prefixed
+      def self.table_name_prefix
+        "prefixed_"
+      end
+
+      class Company < ActiveRecord::Base
+      end
+
+      class Firm < Company
+        self.table_name = "companies"
+      end
+
+      module Nested
+        class Company < ActiveRecord::Base
+        end
+      end
+    end
+
+    module Suffixed
+      def self.table_name_suffix
+        "_suffixed"
+      end
+
+      class Company < ActiveRecord::Base
+      end
+
+      class Firm < Company
+        self.table_name = "companies"
+      end
+
+      module Nested
+        class Company < ActiveRecord::Base
+        end
+      end
+    end
+  end
+
+  module Billing
+    class Firm < ActiveRecord::Base
+      self.table_name = "companies"
+    end
+
+    module Nested
+      class Firm < ActiveRecord::Base
+        self.table_name = "companies"
+      end
+    end
+
+    class Account < ActiveRecord::Base
+      with_options(foreign_key: :firm_id) do |i|
+        i.belongs_to :firm, class_name: "MyApplication::Business::Firm"
+        i.belongs_to :qualified_billing_firm, class_name: "MyApplication::Billing::Firm"
+        i.belongs_to :unqualified_billing_firm, class_name: "Firm"
+        i.belongs_to :nested_qualified_billing_firm, class_name: "MyApplication::Billing::Nested::Firm"
+        i.belongs_to :nested_unqualified_billing_firm, class_name: "Nested::Firm"
+      end
+
+      validate :check_empty_credit_limit
+
+      private
+        def check_empty_credit_limit
+          errors.add("credit_card", :blank) if credit_card.blank?
+        end
+    end
+  end
+end

data/test/models/computer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Computer < ActiveRecord::Base
+  belongs_to :developer, foreign_key: "developer"
+end

data/test/models/contact.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ContactFakeColumns
+  def self.extended(base)
+    base.class_eval do
+      establish_connection(adapter: "fake")
+
+      connection.data_sources = [table_name]
+      connection.primary_keys = {
+        table_name => "id"
+      }
+
+      column :id,             "integer"
+      column :name,           "string"
+      column :age,            "integer"
+      column :avatar,         "binary"
+      column :created_at,     "datetime"
+      column :awesome,        "boolean"
+      column :preferences,    "string"
+      column :alternative_id, "integer"
+
+      serialize :preferences
+
+      belongs_to :alternative, class_name: "Contact"
+    end
+  end
+
+  # mock out self.columns so no pesky db is needed for these tests
+  def column(name, sql_type = nil, options = {})
+    connection.merge_column(table_name, name, sql_type, options)
+  end
+end
+
+class Contact < ActiveRecord::Base
+  extend ContactFakeColumns
+end
+
+class ContactSti < ActiveRecord::Base
+  extend ContactFakeColumns
+  column :type, "string"
+
+  def type; "ContactSti" end
+end

data/test/models/content.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class Content < ActiveRecord::Base
+  self.table_name = "content"
+  has_one :content_position, dependent: :destroy
+
+  def self.destroyed_ids
+    @destroyed_ids ||= []
+  end
+
+  before_destroy do |object|
+    Content.destroyed_ids << object.id
+  end
+end
+
+class ContentWhichRequiresTwoDestroyCalls < ActiveRecord::Base
+  self.table_name = "content"
+  has_one :content_position, foreign_key: "content_id", dependent: :destroy
+
+  after_initialize do
+    @destroy_count = 0
+  end
+
+  before_destroy do
+    @destroy_count += 1
+    if @destroy_count == 1
+      throw :abort
+    end
+  end
+end
+
+class ContentPosition < ActiveRecord::Base
+  belongs_to :content, dependent: :destroy
+
+  def self.destroyed_ids
+    @destroyed_ids ||= []
+  end
+
+  before_destroy do |object|
+    ContentPosition.destroyed_ids << object.id
+  end
+end

data/test/models/contract.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Contract < ActiveRecord::Base
+  belongs_to :company
+  belongs_to :developer, primary_key: :id
+  belongs_to :firm, foreign_key: "company_id"
+
+  attribute :metadata, :json
+
+  before_save :hi, :update_metadata
+  after_save :bye
+
+  attr_accessor :hi_count, :bye_count
+
+  def hi
+    @hi_count ||= 0
+    @hi_count += 1
+  end
+
+  def bye
+    @bye_count ||= 0
+    @bye_count += 1
+  end
+
+  def update_metadata
+    self.metadata = { company_id: company_id, developer_id: developer_id }
+  end
+end
+
+class NewContract < Contract
+  validates :company_id, presence: true
+end
+
+class SpecialContract < ActiveRecord::Base
+  self.table_name = "contracts"
+  belongs_to :company
+  belongs_to :special_developer, foreign_key: "developer_id"
+end

data/test/models/country.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Country < ActiveRecord::Base
+  has_and_belongs_to_many :treaties
+end

data/test/models/course.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "models/arunit2_model"
+
+class Course < ARUnit2Model
+  belongs_to :college
+  has_many :entrants
+end