ibm_db 5.6.1 → 5.7.0

data/test/models/car.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 class Car < ActiveRecord::Base
+  belongs_to :person, counter_cache: true
   has_many :bulbs
   has_many :all_bulbs, -> { unscope(where: :name) }, class_name: "Bulb"
   has_many :all_bulbs2, -> { unscope(:where) }, class_name: "Bulb"
@@ -13,7 +14,7 @@ class Car < ActiveRecord::Base
 
   has_one :bulb
 
-  has_many :tyres
+  has_many :tyres, counter_cache: :custom_tyres_count
   has_many :engines, dependent: :destroy, inverse_of: :my_car
   has_many :wheels, as: :wheelable, dependent: :destroy
 
@@ -34,3 +35,9 @@ end
 class FastCar < Car
   default_scope { order("name desc") }
 end
+
+class BrokenCar < Car
+  after_save do
+    raise ActiveRecord::Rollback
+  end
+end

data/test/models/cat.rb

@@ -3,7 +3,7 @@
 class Cat < ActiveRecord::Base
   self.abstract_class = true
 
-  enum gender: [:female, :male]
+  enum :gender, [:female, :male]
 
   default_scope -> { where(is_vegetarian: false) }
 end

data/test/models/category.rb

@@ -16,7 +16,6 @@ class Category < ActiveRecord::Base
                           -> { where title: "Yet Another Testing Title" },
                           class_name: "Post"
 
-  has_and_belongs_to_many :popular_grouped_posts, -> { group("posts.type").having("sum(comments.post_id) > 2").includes(:comments) }, class_name: "Post"
   has_and_belongs_to_many :posts_grouped_by_title, -> { group("title").select("title") }, class_name: "Post"
 
   def self.what_are_you
@@ -31,6 +30,9 @@ class Category < ActiveRecord::Base
   has_many :authors, through: :categorizations
   has_many :authors_with_select, -> { select "authors.*, categorizations.post_id" }, through: :categorizations, source: :author
 
+  has_many :essays, primary_key: :name
+  has_many :human_writers_of_typed_essays, -> { where(essays: { type: TypedEssay.name }) }, through: :essays, source: :writer, source_type: "Human", primary_key: :name
+
   scope :general, -> { where(name: "General") }
 
   # Should be delegated `ast` and `locked` to `arel`.

data/test/models/chat_message.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ChatMessage < ActiveRecord::Base
+end
+
+class ChatMessageCustomPk < ActiveRecord::Base
+  self.table_name = "chat_messages_custom_pk"
+end

data/test/models/chef.rb

@@ -8,3 +8,55 @@ end
 class ChefList < Chef
   belongs_to :employable_list, polymorphic: true
 end
+
+class ChefWithPolymorphicInverseOf < Chef
+  attr_reader :before_validation_callbacks_counter
+  attr_reader :before_create_callbacks_counter
+  attr_reader :before_save_callbacks_counter
+
+  attr_reader :after_validation_callbacks_counter
+  attr_reader :after_create_callbacks_counter
+  attr_reader :after_save_callbacks_counter
+
+  belongs_to :employable, polymorphic: true, inverse_of: :chef
+  accepts_nested_attributes_for :employable
+
+  before_validation :update_before_validation_counter
+  before_create :update_before_create_counter
+  before_save :update_before_save_counter
+
+  after_validation :update_after_validation_counter
+  after_create :update_after_create_counter
+  after_save :update_after_save_counter
+
+  private
+    def update_before_validation_counter
+      @before_validation_callbacks_counter ||= 0
+      @before_validation_callbacks_counter += 1
+    end
+
+    def update_before_create_counter
+      @before_create_callbacks_counter ||= 0
+      @before_create_callbacks_counter += 1
+    end
+
+    def update_before_save_counter
+      @before_save_callbacks_counter ||= 0
+      @before_save_callbacks_counter += 1
+    end
+
+    def update_after_validation_counter
+      @after_validation_callbacks_counter ||= 0
+      @after_validation_callbacks_counter += 1
+    end
+
+    def update_after_create_counter
+      @after_create_callbacks_counter ||= 0
+      @after_create_callbacks_counter += 1
+    end
+
+    def update_after_save_counter
+      @after_save_callbacks_counter ||= 0
+      @after_save_callbacks_counter += 1
+    end
+end

data/test/models/clothing_item.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ClothingItem < ActiveRecord::Base
+  query_constraints :clothing_type, :color
+end
+
+class ClothingItem::Used < ClothingItem
+end
+
+class ClothingItem::Sized < ClothingItem
+  query_constraints :clothing_type, :color, :size
+end

data/test/models/club.rb

@@ -8,7 +8,10 @@ class Club < ActiveRecord::Base
   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
+  has_many :favorites, -> { where(memberships: { favorite: true }) }, through: :memberships, source: :member
+
+  has_many :custom_memberships, class_name: "Membership"
+  has_many :custom_favorites, -> { where(memberships: { favorite: true }) }, through: :custom_memberships, source: :member
 
   scope :general, -> { left_joins(:category).where(categories: { name: "General" }).unscope(:limit) }
 

data/test/models/comment.rb

@@ -10,10 +10,12 @@ class Comment < ActiveRecord::Base
   scope :for_first_post, -> { where(post_id: 1) }
   scope :for_first_author, -> { joins(:post).where("posts.author_id" => 1) }
   scope :created, -> { all }
+  scope :ordered_by_post_id, -> { order("comments.post_id DESC") }
 
   belongs_to :post, counter_cache: true
   belongs_to :author,   polymorphic: true
   belongs_to :resource, polymorphic: true
+  belongs_to :origin, polymorphic: true
   belongs_to :company, foreign_key: "company"
 
   has_many :ratings
@@ -21,12 +23,12 @@ class Comment < ActiveRecord::Base
   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
+  has_one :post_with_inverse, ->(comment) { where(id: comment.post_id) }, class_name: "FirstPost", inverse_of: :comment_with_inverse
 
-  alias_attribute :entry, :post
+  has_many :children, class_name: "Comment", inverse_of: :parent
+  belongs_to :parent, class_name: "Comment", counter_cache: :children_count, inverse_of: :children
 
-  enum label: [:default, :child]
+  enum :label, [:default, :child]
 
   class ::OopsError < RuntimeError; end
 
@@ -64,6 +66,7 @@ class Comment < ActiveRecord::Base
 end
 
 class SpecialComment < Comment
+  belongs_to :ordinary_post, foreign_key: :post_id, class_name: "Post"
   has_one :author, through: :post
   default_scope { where(deleted_at: nil) }
 

data/test/models/comment_overlapping_counter_cache.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class CommentOverlappingCounterCache < ActiveRecord::Base
+  belongs_to :user_comments_count, counter_cache: :comments_count
+  belongs_to :post_comments_count, class_name: "PostCommentsCount"
+  belongs_to :commentable, polymorphic: true, counter_cache: :comments_count
+end
+
+class UserCommentsCount < ActiveRecord::Base
+  has_many :comments, as: :commentable, class_name: "CommentOverlappingCounterCache"
+end
+
+class PostCommentsCount < ActiveRecord::Base
+  has_many :comments, class_name: "CommentOverlappingCounterCache"
+end

data/test/models/company.rb

@@ -7,6 +7,8 @@ end
 class Company < AbstractCompany
   self.sequence_name = :companies_nonstd_seq
 
+  enum :status, [:active, :suspended]
+
   validates_presence_of :name
 
   has_one :account, foreign_key: "firm_id"
@@ -56,7 +58,7 @@ class Firm < Company
   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_of_firm, -> { order "id" }, 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
@@ -84,6 +86,8 @@ class Firm < Company
   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 :client, foreign_key: "client_of"
+
   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
@@ -134,7 +138,7 @@ class Agency < Firm
 end
 
 class Client < Company
-  belongs_to :firm, foreign_key: "client_of"
+  belongs_to :firm, foreign_key: "client_of", inverse_of: :client
   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"
@@ -209,6 +213,16 @@ class ExclusivelyDependentFirm < Company
   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 LargeClient < Client
+  attribute :extra_size, :integer
+
+  after_initialize :set_extra_size
+
+  def set_extra_size
+    self[:extra_size] = 50
+  end
+end
+
 class SpecialClient < Client
 end
 

data/test/models/computer.rb

@@ -2,4 +2,5 @@
 
 class Computer < ActiveRecord::Base
   belongs_to :developer, foreign_key: "developer"
+  has_one :firm, through: :developer
 end

data/test/models/contact.rb

@@ -5,8 +5,8 @@ module ContactFakeColumns
     base.class_eval do
       establish_connection(adapter: "fake")
 
-      connection.data_sources = [table_name]
-      connection.primary_keys = {
+      lease_connection.data_sources = [table_name]
+      lease_connection.primary_keys = {
         table_name => "id"
       }
 
@@ -27,7 +27,7 @@ module ContactFakeColumns
 
   # 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)
+    lease_connection.merge_column(table_name, name, sql_type, options)
   end
 end
 

data/test/models/contract.rb

@@ -23,7 +23,11 @@ class Contract < ActiveRecord::Base
   end
 
   def update_metadata
-    self.metadata = { company_id: company_id, developer_id: developer_id }
+    # 'code' makes the JSON string consistently orderable, which is used
+    # by RelationsTest "joins with order by custom attribute". Without
+    # this it would still pass 99% of the time, but fail when two
+    # records' company_id lexical and numeric order differ (99, 100).
+    self.metadata = { code: company_id && "%08x" % company_id, company_id: company_id, developer_id: developer_id }
   end
 end
 

data/test/models/cpk/author.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Author < ActiveRecord::Base
+    self.table_name = :cpk_authors
+
+    has_many :books, class_name: "Cpk::Book", dependent: :delete_all
+  end
+end

data/test/models/cpk/book.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Book < ActiveRecord::Base
+    attr_accessor :fail_destroy
+
+    self.table_name = :cpk_books
+    belongs_to :order, autosave: true, foreign_key: [:shop_id, :order_id], counter_cache: true
+    belongs_to :order_explicit_fk_pk, class_name: "Cpk::Order", foreign_key: [:shop_id, :order_id], primary_key: [:shop_id, :id]
+    belongs_to :author, class_name: "Cpk::Author"
+
+    has_many :chapters, foreign_key: [:author_id, :book_id]
+    accepts_nested_attributes_for :chapters
+
+    before_destroy :prevent_destroy_if_set
+
+    generates_token_for :test
+
+    private
+      def prevent_destroy_if_set
+        throw(:abort) if fail_destroy
+      end
+  end
+
+  class BestSeller < Book
+  end
+
+  class BrokenBook < Book
+    belongs_to :order, class_name: "Cpk::OrderWithSpecialPrimaryKey"
+  end
+
+  class BrokenBookWithNonCpkOrder < Book
+    belongs_to :order, class_name: "Cpk::NonCpkOrder", foreign_key: [:shop_id, :order_id]
+  end
+
+  class NonCpkBook < Book
+    self.primary_key = :id
+
+    belongs_to :non_cpk_order, foreign_key: [:order_id]
+  end
+
+  class NullifiedBook < Book
+    has_one :chapter, foreign_key: [:author_id, :book_id], dependent: :nullify
+  end
+
+  class BookWithOrderAgreements < Book
+    has_many :order_agreements, through: :order
+    has_one :order_agreement, through: :order, source: :order_agreements
+  end
+
+  class BookWithRequiredOrder < ActiveRecord::Base
+    self.table_name = :cpk_books
+    belongs_to :order, class_name: "Cpk::Order", foreign_key: [:shop_id, :order_id], primary_key: [:shop_id, :id], optional: false
+  end
+end

data/test/models/cpk/book_destroy_async.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class BookDestroyAsync < ActiveRecord::Base
+    self.table_name = :cpk_books
+
+    has_many :chapters, foreign_key: [:author_id, :book_id], class_name: "Cpk::ChapterDestroyAsync", dependent: :destroy_async
+  end
+end

data/test/models/cpk/car.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Car < ActiveRecord::Base
+    self.table_name = :cpk_cars
+
+    has_many :car_reviews, foreign_key: [:car_make, :car_model]
+  end
+end

data/test/models/cpk/car_review.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class CarReview < ActiveRecord::Base
+    self.table_name = :cpk_car_reviews
+
+    belongs_to :car, foreign_key: [:car_make, :car_model]
+  end
+end

data/test/models/cpk/chapter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Chapter < ActiveRecord::Base
+    self.table_name = :cpk_chapters
+    # explicit definition is to allow schema definition to be simplified
+    # to be shared between different databases
+    self.primary_key = [:author_id, :id]
+
+    belongs_to :book, foreign_key: [:author_id, :book_id]
+  end
+
+  class OptionalChapter < Chapter
+    belongs_to :book, foreign_key: [:author_id, :book_id], optional: true
+  end
+end

data/test/models/cpk/chapter_destroy_async.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class ChapterDestroyAsync < ActiveRecord::Base
+    self.table_name = :cpk_chapters
+    self.primary_key = [:author_id, :id]
+
+    belongs_to :book, foreign_key: [:author_id, :book_id], class_name: "Cpk::BookDestroyAsync"
+  end
+end

data/test/models/cpk/comment.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Comment < ActiveRecord::Base
+    self.table_name = :cpk_comments
+    belongs_to :commentable, class_name: "Cpk::Post", foreign_key: %i[commentable_title commentable_author], polymorphic: true
+    belongs_to :post, class_name: "Cpk::Post", foreign_key: %i[commentable_title commentable_author]
+  end
+end

data/test/models/cpk/order.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Order < ActiveRecord::Base
+    self.table_name = :cpk_orders
+    # explicit definition is to allow schema definition to be simplified
+    # to be shared between different databases
+    self.primary_key = [:shop_id, :id]
+
+    alias_attribute :id_value, :id
+
+    has_many :order_agreements
+    has_many :books, foreign_key: [:shop_id, :order_id]
+    has_one :book, foreign_key: [:shop_id, :order_id]
+    has_many :order_tags
+    has_many :tags, through: :order_tags
+  end
+
+  class BrokenOrder < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books
+    has_one :book
+  end
+
+  class OrderWithSpecialPrimaryKey < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books, foreign_key: [:shop_id, :status]
+    has_one :book, foreign_key: [:shop_id, :status]
+  end
+
+  class BrokenOrderWithNonCpkBooks < Order
+    self.primary_key = [:shop_id, :status]
+
+    has_many :books, class_name: "Cpk::NonCpkBook"
+    has_one :book, class_name: "Cpk::NonCpkBook"
+  end
+
+  class NonCpkOrder < Order
+    self.primary_key = :id
+  end
+
+  class OrderWithPrimaryKeyAssociatedBook < Order
+    has_one :book, foreign_key: :order_id
+  end
+
+  class OrderWithNullifiedBook < Order
+    has_one :book, foreign_key: [:shop_id, :order_id], dependent: :nullify
+  end
+
+  class OrderWithSingularBookChapters < Order
+    has_many :chapters, through: :book
+  end
+end

data/test/models/cpk/order_agreement.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  # This is a non composite primary key model that is associated with `Cpk::Order` via `id` only.
+  class OrderAgreement < ActiveRecord::Base
+    self.table_name = :cpk_order_agreements
+
+    belongs_to :order
+  end
+end

data/test/models/cpk/order_tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class OrderTag < ActiveRecord::Base
+    self.table_name = :cpk_order_tags
+
+    belongs_to :tag
+    belongs_to :order
+  end
+end

data/test/models/cpk/post.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Post < ActiveRecord::Base
+    self.table_name = :cpk_posts
+    has_many :comments, class_name: "Cpk::Comment", foreign_key: %i[commentable_title commentable_author], as: :commentable
+    has_many :posts_tags, class_name: "Cpk::PostsTag", foreign_key: %i[post_title post_author]
+    has_many :tags, through: :posts_tags, class_name: "Cpk::Tag"
+  end
+end

data/test/models/cpk/posts_tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class PostsTag < ActiveRecord::Base
+    self.table_name = :cpk_posts_tags
+
+    belongs_to :post, class_name: "Cpk:Post", foreign_key: %i[post_title post_author]
+    belongs_to :tag, class_name: "Cpk::Tag"
+  end
+end

data/test/models/cpk/review.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Review < ActiveRecord::Base
+    self.table_name = :cpk_reviews
+
+    belongs_to :book, class_name: "Cpk::Book", foreign_key: [:author_id, :number]
+  end
+end

data/test/models/cpk/tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Cpk
+  class Tag < ActiveRecord::Base
+    self.table_name = :cpk_tags
+
+    has_many :order_tags
+    has_many :orders, through: :order_tags
+  end
+end

data/test/models/cpk.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative "cpk/author"
+require_relative "cpk/book"
+require_relative "cpk/order"
+require_relative "cpk/review"
+require_relative "cpk/order_agreement"
+require_relative "cpk/order_tag"
+require_relative "cpk/tag"
+require_relative "cpk/chapter"
+require_relative "cpk/post"
+require_relative "cpk/posts_tag"
+require_relative "cpk/comment"
+require_relative "cpk/car"
+require_relative "cpk/car_review"

data/test/models/customer.rb

@@ -4,7 +4,9 @@ class Customer < ActiveRecord::Base
   cattr_accessor :gps_conversion_was_run
 
   composed_of :address, mapping: [ %w(address_street street), %w(address_city city), %w(address_country country) ], allow_nil: true
-  composed_of :balance, class_name: "Money", mapping: %w(balance amount)
+  composed_of :address_hash_mapping, class_name: "Address",
+              mapping: { address_street: :street, address_city: :city, address_country: :country }, allow_nil: true
+  composed_of :balance, class_name: "Money", mapping: %i(balance amount)
   composed_of :gps_location, allow_nil: true
   composed_of :non_blank_gps_location, class_name: "GpsLocation", allow_nil: true, mapping: %w(gps_location gps_location),
               converter: lambda { |gps| self.gps_conversion_was_run = true; gps.blank? ? nil : GpsLocation.new(gps) }

data/test/models/destroy_async_parent.rb

@@ -8,7 +8,7 @@
    has_many :dl_keyed_has_many, dependent: :destroy_async,
      foreign_key: :many_key, primary_key: :parent_id
    has_many :dl_keyed_join, dependent: :destroy_async,
-     foreign_key: :destroy_async_parent_id, primary_key: :joins_key
+     foreign_key: :destroy_async_parent_id, primary_key: :parent_id
    has_many :dl_keyed_has_many_through,
      through: :dl_keyed_join, dependent: :destroy_async,
      foreign_key: :dl_has_many_through_key_id, primary_key: :through_key