ibm_db 3.0.0-x86-mingw32 → 3.0.1-x86-mingw32

data/test/models/person.rb

@@ -0,0 +1,143 @@
+class Person < ActiveRecord::Base
+  has_many :readers
+  has_many :secure_readers
+  has_one  :reader
+
+  has_many :posts, :through => :readers
+  has_many :secure_posts, :through => :secure_readers
+  has_many :posts_with_no_comments, -> { includes(:comments).where('comments.id is null').references(:comments) },
+                                    :through => :readers, :source => :post
+
+  has_many :friendships, foreign_key: 'friend_id'
+  # friends_too exists to test a bug, and probably shouldn't be used elsewhere
+  has_many :friends_too, foreign_key: 'friend_id', class_name: 'Friendship'
+  has_many :followers, through: :friendships
+
+  has_many :references
+  has_many :bad_references
+  has_many :fixed_bad_references, -> { where :favourite => true }, :class_name => 'BadReference'
+  has_one  :favourite_reference, -> { where 'favourite=?', true }, :class_name => 'Reference'
+  has_many :posts_with_comments_sorted_by_comment_id, -> { includes(:comments).order('comments.id') }, :through => :readers, :source => :post
+  has_many :first_posts, -> { where(id: [1, 2]) }, through: :readers
+
+  has_many :jobs, :through => :references
+  has_many :jobs_with_dependent_destroy,    :source => :job, :through => :references, :dependent => :destroy
+  has_many :jobs_with_dependent_delete_all, :source => :job, :through => :references, :dependent => :delete_all
+  has_many :jobs_with_dependent_nullify,    :source => :job, :through => :references, :dependent => :nullify
+
+  belongs_to :primary_contact, :class_name => 'Person'
+  has_many :agents, :class_name => 'Person', :foreign_key => 'primary_contact_id'
+  has_many :agents_of_agents, :through => :agents, :source => :agents
+  belongs_to :number1_fan, :class_name => 'Person'
+
+  has_many :personal_legacy_things, :dependent => :destroy
+
+  has_many :agents_posts,         :through => :agents,       :source => :posts
+  has_many :agents_posts_authors, :through => :agents_posts, :source => :author
+  has_many :essays, primary_key: "first_name", foreign_key: "writer_id"
+
+  scope :males,   -> { where(:gender => 'M') }
+  scope :females, -> { where(:gender => 'F') }
+end
+
+class PersonWithDependentDestroyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :destroy
+end
+
+class PersonWithDependentDeleteAllJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :delete_all
+end
+
+class PersonWithDependentNullifyJobs < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_many :references, :foreign_key => :person_id
+  has_many :jobs, :source => :job, :through => :references, :dependent => :nullify
+end
+
+
+class LoosePerson < ActiveRecord::Base
+  self.table_name = 'people'
+  self.abstract_class = true
+
+  has_one    :best_friend,    :class_name => 'LoosePerson', :foreign_key => :best_friend_id
+  belongs_to :best_friend_of, :class_name => 'LoosePerson', :foreign_key => :best_friend_of_id
+  has_many   :best_friends,   :class_name => 'LoosePerson', :foreign_key => :best_friend_id
+
+  accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
+end
+
+class LooseDescendant < LoosePerson; end
+
+class TightPerson < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_one    :best_friend,    :class_name => 'TightPerson', :foreign_key => :best_friend_id
+  belongs_to :best_friend_of, :class_name => 'TightPerson', :foreign_key => :best_friend_of_id
+  has_many   :best_friends,   :class_name => 'TightPerson', :foreign_key => :best_friend_id
+
+  accepts_nested_attributes_for :best_friend, :best_friend_of, :best_friends
+end
+
+class TightDescendant < TightPerson; end
+
+class RichPerson < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_and_belongs_to_many :treasures, :join_table => 'peoples_treasures'
+
+  before_validation :run_before_create, on: :create
+  before_validation :run_before_validation
+
+  private
+
+  def run_before_create
+    self.first_name = first_name.to_s + 'run_before_create'
+  end
+
+  def run_before_validation
+    self.first_name = first_name.to_s + 'run_before_validation'
+  end
+end
+
+class NestedPerson < ActiveRecord::Base
+  self.table_name = 'people'
+
+  has_one :best_friend, :class_name => 'NestedPerson', :foreign_key => :best_friend_id
+  accepts_nested_attributes_for :best_friend, :update_only => true
+
+  def comments=(new_comments)
+    raise RuntimeError
+  end
+
+  def best_friend_first_name=(new_name)
+    assign_attributes({ :best_friend_attributes => { :first_name => new_name } })
+  end
+end
+
+class Insure
+  INSURES = %W{life annuality}
+
+  def self.load mask
+    INSURES.select do |insure|
+      (1 << INSURES.index(insure)) & mask.to_i > 0
+    end
+  end
+
+  def self.dump insures
+    numbers = insures.map { |insure| INSURES.index(insure) }
+    numbers.inject(0) { |sum, n| sum + (1 << n) }
+  end
+end
+
+class SerializedPerson < ActiveRecord::Base
+  self.table_name = 'people'
+
+  serialize :insures, Insure
+end

data/test/models/personal_legacy_thing.rb

@@ -0,0 +1,4 @@
+class PersonalLegacyThing < ActiveRecord::Base
+  self.locking_column = :version
+  belongs_to :person, :counter_cache => true
+end

data/test/models/pet.rb

@@ -0,0 +1,15 @@
+class Pet < ActiveRecord::Base
+  attr_accessor :current_user
+
+  self.primary_key = :pet_id
+  belongs_to :owner, :touch => true
+  has_many :toys
+
+  class << self
+    attr_accessor :after_destroy_output
+  end
+
+  after_destroy do |record|
+    Pet.after_destroy_output = record.current_user
+  end
+end

data/test/models/pirate.rb

@@ -0,0 +1,92 @@
+class Pirate < ActiveRecord::Base
+  belongs_to :parrot, :validate => true
+  belongs_to :non_validated_parrot, :class_name => 'Parrot'
+  has_and_belongs_to_many :parrots, -> { order('parrots.id ASC') }, :validate => true
+  has_and_belongs_to_many :non_validated_parrots, :class_name => 'Parrot'
+  has_and_belongs_to_many :parrots_with_method_callbacks, :class_name => "Parrot",
+    :before_add    => :log_before_add,
+    :after_add     => :log_after_add,
+    :before_remove => :log_before_remove,
+    :after_remove  => :log_after_remove
+  has_and_belongs_to_many :parrots_with_proc_callbacks, :class_name => "Parrot",
+    :before_add    => proc {|p,pa| p.ship_log << "before_adding_proc_parrot_#{pa.id || '<new>'}"},
+    :after_add     => proc {|p,pa| p.ship_log << "after_adding_proc_parrot_#{pa.id || '<new>'}"},
+    :before_remove => proc {|p,pa| p.ship_log << "before_removing_proc_parrot_#{pa.id}"},
+    :after_remove  => proc {|p,pa| p.ship_log << "after_removing_proc_parrot_#{pa.id}"}
+  has_and_belongs_to_many :autosaved_parrots, class_name: "Parrot", autosave: true
+
+  has_many :treasures, :as => :looter
+  has_many :treasure_estimates, :through => :treasures, :source => :price_estimates
+
+  has_one :ship
+  has_one :update_only_ship, :class_name => 'Ship'
+  has_one :non_validated_ship, :class_name => 'Ship'
+  has_many :birds, -> { order('birds.id ASC') }
+  has_many :birds_with_method_callbacks, :class_name => "Bird",
+    :before_add    => :log_before_add,
+    :after_add     => :log_after_add,
+    :before_remove => :log_before_remove,
+    :after_remove  => :log_after_remove
+  has_many :birds_with_proc_callbacks, :class_name => "Bird",
+    :before_add     => proc {|p,b| p.ship_log << "before_adding_proc_bird_#{b.id || '<new>'}"},
+    :after_add      => proc {|p,b| p.ship_log << "after_adding_proc_bird_#{b.id || '<new>'}"},
+    :before_remove  => proc {|p,b| p.ship_log << "before_removing_proc_bird_#{b.id}"},
+    :after_remove   => proc {|p,b| p.ship_log << "after_removing_proc_bird_#{b.id}"}
+  has_many :birds_with_reject_all_blank, :class_name => "Bird"
+
+  has_one :foo_bulb, -> { where :name => 'foo' }, :foreign_key => :car_id, :class_name => "Bulb"
+
+  accepts_nested_attributes_for :parrots, :birds, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
+  accepts_nested_attributes_for :ship, :allow_destroy => true, :reject_if => proc { |attributes| attributes.empty? }
+  accepts_nested_attributes_for :update_only_ship, :update_only => true
+  accepts_nested_attributes_for :parrots_with_method_callbacks, :parrots_with_proc_callbacks,
+    :birds_with_method_callbacks, :birds_with_proc_callbacks, :allow_destroy => true
+  accepts_nested_attributes_for :birds_with_reject_all_blank, :reject_if => :all_blank
+
+  validates_presence_of :catchphrase
+
+  def ship_log
+    @ship_log ||= []
+  end
+
+  def reject_empty_ships_on_create(attributes)
+    attributes.delete('_reject_me_if_new').present? && !persisted?
+  end
+
+  attr_accessor :cancel_save_from_callback, :parrots_limit
+  before_save :cancel_save_callback_method, :if => :cancel_save_from_callback
+  def cancel_save_callback_method
+    false
+  end
+
+  private
+    def log_before_add(record)
+      log(record, "before_adding_method")
+    end
+
+    def log_after_add(record)
+      log(record, "after_adding_method")
+    end
+
+    def log_before_remove(record)
+      log(record, "before_removing_method")
+    end
+
+    def log_after_remove(record)
+      log(record, "after_removing_method")
+    end
+
+    def log(record, callback)
+      ship_log << "#{callback}_#{record.class.name.downcase}_#{record.id || '<new>'}"
+    end
+end
+
+class DestructivePirate < Pirate
+  has_one :dependent_ship, :class_name => 'Ship', :foreign_key => :pirate_id, :dependent => :destroy
+end
+
+class FamousPirate < ActiveRecord::Base
+  self.table_name = 'pirates'
+  has_many :famous_ships
+  validates_presence_of :catchphrase, on: :conference
+end

data/test/models/possession.rb

@@ -0,0 +1,3 @@
+class Possession < ActiveRecord::Base
+  self.table_name = 'having'
+end

data/test/models/post.rb

@@ -0,0 +1,264 @@
+class Post < ActiveRecord::Base
+  class CategoryPost < ActiveRecord::Base
+    self.table_name = "categories_posts"
+    belongs_to :category
+    belongs_to :post
+  end
+
+  module NamedExtension
+    def author
+      'lifo'
+    end
+  end
+
+  module NamedExtension2
+    def greeting
+      "hello"
+    end
+  end
+
+  scope :containing_the_letter_a, -> { where("body LIKE '%a%'") }
+  scope :ranked_by_comments,      -> { order("comments_count DESC") }
+
+  scope :limit_by, lambda {|l| limit(l) }
+
+  belongs_to :author
+
+  belongs_to :author_with_posts, -> { includes(:posts) }, :class_name => "Author", :foreign_key => :author_id
+  belongs_to :author_with_address, -> { includes(:author_address) }, :class_name => "Author", :foreign_key => :author_id
+
+  def first_comment
+    super.body
+  end
+  has_one :first_comment, -> { order('id ASC') }, :class_name => 'Comment'
+  has_one :last_comment, -> { order('id desc') }, :class_name => 'Comment'
+
+  scope :with_special_comments, -> { joins(:comments).where(:comments => {:type => 'SpecialComment'}) }
+  scope :with_very_special_comments, -> { joins(:comments).where(:comments => {:type => 'VerySpecialComment'}) }
+  scope :with_post, ->(post_id) { joins(:comments).where(:comments => { :post_id => post_id }) }
+
+  scope :with_comments, -> { preload(:comments) }
+  scope :with_tags, -> { preload(:taggings) }
+
+  scope :tagged_with, ->(id) { joins(:taggings).where(taggings: { tag_id: id }) }
+  scope :tagged_with_comment, ->(comment) { joins(:taggings).where(taggings: { comment: comment }) }
+
+  has_many   :comments do
+    def find_most_recent
+      order("id DESC").first
+    end
+
+    def newest
+      created.last
+    end
+
+    def the_association
+      proxy_association
+    end
+  end
+
+  has_many :comments_with_extend, extend: NamedExtension, class_name: "Comment", foreign_key: "post_id" do
+    def greeting
+      "hello"
+    end
+  end
+
+  has_many :comments_with_extend_2, extend: [NamedExtension, NamedExtension2], class_name: "Comment", foreign_key: "post_id"
+
+  has_many :author_favorites, :through => :author
+  has_many :author_categorizations, :through => :author, :source => :categorizations
+  has_many :author_addresses, :through => :author
+  has_many :author_address_extra_with_address,
+    through: :author_with_address,
+    source: :author_address_extra
+
+  has_many :comments_with_interpolated_conditions,
+    ->(p) { where "#{"#{p.aliased_table_name}." rescue ""}body = ?", 'Thank you for the welcome' },
+    :class_name => 'Comment'
+
+  has_one  :very_special_comment
+  has_one  :very_special_comment_with_post, -> { includes(:post) }, :class_name => "VerySpecialComment"
+  has_one :very_special_comment_with_post_with_joins, -> { joins(:post).order('posts.id') }, class_name: "VerySpecialComment"
+  has_many :special_comments
+  has_many :nonexistant_comments, -> { where 'comments.id < 0' }, :class_name => 'Comment'
+
+  has_many :special_comments_ratings, :through => :special_comments, :source => :ratings
+  has_many :special_comments_ratings_taggings, :through => :special_comments_ratings, :source => :taggings
+
+  has_many :category_posts, :class_name => 'CategoryPost'
+  has_many :scategories, through: :category_posts, source: :category
+  has_and_belongs_to_many :categories
+  has_and_belongs_to_many :special_categories, :join_table => "categories_posts", :association_foreign_key => 'category_id'
+
+  has_many :taggings, :as => :taggable, :counter_cache => :tags_count
+  has_many :tags, :through => :taggings do
+    def add_joins_and_select
+      select('tags.*, authors.id as author_id')
+        .joins('left outer join posts on taggings.taggable_id = posts.id left outer join authors on posts.author_id = authors.id')
+        .to_a
+    end
+  end
+
+  has_many :taggings_with_delete_all, :class_name => 'Tagging', :as => :taggable, :dependent => :delete_all, counter_cache: :taggings_with_delete_all_count
+  has_many :taggings_with_destroy, :class_name => 'Tagging', :as => :taggable, :dependent => :destroy, counter_cache: :taggings_with_destroy_count
+
+  has_many :tags_with_destroy, :through => :taggings, :source => :tag, :dependent => :destroy, counter_cache: :tags_with_destroy_count
+  has_many :tags_with_nullify, :through => :taggings, :source => :tag, :dependent => :nullify, counter_cache: :tags_with_nullify_count
+
+  has_many :misc_tags, -> { where :tags => { :name => 'Misc' } }, :through => :taggings, :source => :tag
+  has_many :funky_tags, :through => :taggings, :source => :tag
+  has_many :super_tags, :through => :taggings
+  has_many :tags_with_primary_key, :through => :taggings, :source => :tag_with_primary_key
+  has_one :tagging, :as => :taggable
+
+  has_many :first_taggings, -> { where :taggings => { :comment => 'first' } }, :as => :taggable, :class_name => 'Tagging'
+  has_many :first_blue_tags, -> { where :tags => { :name => 'Blue' } }, :through => :first_taggings, :source => :tag
+
+  has_many :first_blue_tags_2, -> { where :taggings => { :comment => 'first' } }, :through => :taggings, :source => :blue_tag
+
+  has_many :invalid_taggings, -> { where 'taggings.id < 0' }, :as => :taggable, :class_name => "Tagging"
+  has_many :invalid_tags, :through => :invalid_taggings, :source => :tag
+
+  has_many :categorizations, :foreign_key => :category_id
+  has_many :authors, :through => :categorizations
+
+  has_many :categorizations_using_author_id, :primary_key => :author_id, :foreign_key => :post_id, :class_name => 'Categorization'
+  has_many :authors_using_author_id, :through => :categorizations_using_author_id, :source => :author
+
+  has_many :taggings_using_author_id, :primary_key => :author_id, :as => :taggable, :class_name => 'Tagging'
+  has_many :tags_using_author_id, :through => :taggings_using_author_id, :source => :tag
+
+  has_many :images, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class
+  has_one :main_image, :as => :imageable, :foreign_key => :imageable_identifier, :foreign_type => :imageable_class, :class_name => 'Image'
+
+  has_many :standard_categorizations, :class_name => 'Categorization', :foreign_key => :post_id
+  has_many :author_using_custom_pk,  :through => :standard_categorizations
+  has_many :authors_using_custom_pk, :through => :standard_categorizations
+  has_many :named_categories, :through => :standard_categorizations
+
+  has_many :readers
+  has_many :secure_readers
+  has_many :readers_with_person, -> { includes(:person) }, :class_name => "Reader"
+  has_many :people, :through => :readers
+  has_many :single_people, :through => :readers
+  has_many :people_with_callbacks, :source=>:person, :through => :readers,
+              :before_add    => lambda {|owner, reader| log(:added,   :before, reader.first_name) },
+              :after_add     => lambda {|owner, reader| log(:added,   :after,  reader.first_name) },
+              :before_remove => lambda {|owner, reader| log(:removed, :before, reader.first_name) },
+              :after_remove  => lambda {|owner, reader| log(:removed, :after,  reader.first_name) }
+  has_many :skimmers, -> { where :skimmer => true }, :class_name => 'Reader'
+  has_many :impatient_people, :through => :skimmers, :source => :person
+
+  has_many :lazy_readers
+  has_many :lazy_readers_skimmers_or_not, -> { where(skimmer: [ true, false ]) }, :class_name => 'LazyReader'
+
+  has_many :lazy_people, :through => :lazy_readers, :source => :person
+  has_many :lazy_readers_unscope_skimmers, -> { skimmers_or_not }, :class_name => 'LazyReader'
+  has_many :lazy_people_unscope_skimmers, :through => :lazy_readers_unscope_skimmers, :source => :person
+
+  def self.top(limit)
+    ranked_by_comments.limit_by(limit)
+  end
+
+  def self.written_by(author)
+    where(id: author.posts.pluck(:id))
+  end
+
+  def self.reset_log
+    @log = []
+  end
+
+  def self.log(message=nil, side=nil, new_record=nil)
+    return @log if message.nil?
+    @log << [message, side, new_record]
+  end
+end
+
+class SpecialPost < Post; end
+
+class StiPost < Post
+  self.abstract_class = true
+  has_one :special_comment, :class_name => "SpecialComment"
+end
+
+class SubStiPost < StiPost
+  self.table_name = Post.table_name
+end
+
+class FirstPost < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope { where(:id => 1) }
+
+  has_many :comments, :foreign_key => :post_id
+  has_one  :comment,  :foreign_key => :post_id
+end
+
+class PostWithDefaultInclude < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope { includes(:comments) }
+  has_many :comments, :foreign_key => :post_id
+end
+
+class PostWithSpecialCategorization < Post
+  has_many :categorizations, :foreign_key => :post_id
+  default_scope { where(:type => 'PostWithSpecialCategorization').joins(:categorizations).where(:categorizations => { :special => true }) }
+end
+
+class PostWithDefaultScope < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope { order(:title) }
+end
+
+class PostWithPreloadDefaultScope < ActiveRecord::Base
+  self.table_name = 'posts'
+
+  has_many :readers, foreign_key: 'post_id'
+
+  default_scope { preload(:readers) }
+end
+
+class PostWithIncludesDefaultScope < ActiveRecord::Base
+  self.table_name = 'posts'
+
+  has_many :readers, foreign_key: 'post_id'
+
+  default_scope { includes(:readers) }
+end
+
+class SpecialPostWithDefaultScope < ActiveRecord::Base
+  self.table_name = 'posts'
+  default_scope { where(:id => [1, 5,6]) }
+end
+
+class PostThatLoadsCommentsInAnAfterSaveHook < ActiveRecord::Base
+  self.table_name = 'posts'
+  has_many :comments, class_name: "CommentThatAutomaticallyAltersPostBody", foreign_key: :post_id
+
+  after_save do |post|
+    post.comments.load
+  end
+end
+
+class PostWithAfterCreateCallback < ActiveRecord::Base
+  self.table_name = 'posts'
+  has_many :comments, foreign_key: :post_id
+
+  after_create do |post|
+    update_attribute(:author_id, comments.first.id)
+  end
+end
+
+class PostWithCommentWithDefaultScopeReferencesAssociation < ActiveRecord::Base
+  self.table_name = 'posts'
+  has_many :comment_with_default_scope_references_associations, foreign_key: :post_id
+  has_one :first_comment, class_name: "CommentWithDefaultScopeReferencesAssociation", foreign_key: :post_id
+end
+
+class SerializedPost < ActiveRecord::Base
+  serialize :title
+end
+
+class PostWithConflictingDefaultScope < Post
+  default_scope ->{ where(author_id: 42) }
+  belongs_to :post_with_conflicting_default_scope, foreign_key: :post_id
+end