Ruby on rails 多对多多态关联

我不知道如何创建这个，我想创建一个多对多多态关联

我有一个

问题

模型，它属于一家

公司

现在这个问题可能有很多用户，

组

，或者

公司

。取决于您如何分配它

我希望能够将问题分配给一个/多个用户、一个/多个组或它所属的公司

---

如何进行设置？

在本例中，我将添加一个分配模型，作为问题和分配给它的实体之间的交叉点

创建表 让我们运行生成器来创建所需的文件：

rails g模型分配问题：属于\u受让人\u id:integer受让人\u类型：字符串

然后，让我们打开创建的迁移文件

（db/migrations/…\uu create\u assignments.rb）

：

polymorpic:true

选项告诉ActiveRecord查看

assignment\u type

列以决定从哪个表加载

assignment

class User < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

class Group < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end    

class Company < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

但这会导致非常低效的SQL查询，因为每个受让人都将被加载到一个查询中

相反，您可以这样做：

class Question < ActiveRecord::Base
  has_many :assignments

  # creates a relationship for each assignee type
  ['Company', 'Group', 'User'].each do |type|
    has_many "#{type.downcase}_assignees".to_sym,
        through: :assignments,
        source: :assignee,
        source_type: type
  end

  def assignees
    (company_assignees + group_assignees + user_assignees)
  end
end

类问题

---

这将只导致每个受让人类型有一个查询，这是一个很大的改进。

在这种情况下，我将添加一个分配模型，作为问题和分配给它的实体之间的交叉点

创建表 让我们运行生成器来创建所需的文件：

rails g模型分配问题：属于\u受让人\u id:integer受让人\u类型：字符串

然后，让我们打开创建的迁移文件

（db/migrations/…\uu create\u assignments.rb）

：

polymorpic:true

选项告诉ActiveRecord查看

assignment\u type

列以决定从哪个表加载

assignment

class User < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

class Group < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end    

class Company < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

但这会导致非常低效的SQL查询，因为每个受让人都将被加载到一个查询中

相反，您可以这样做：

class Question < ActiveRecord::Base
  has_many :assignments

  # creates a relationship for each assignee type
  ['Company', 'Group', 'User'].each do |type|
    has_many "#{type.downcase}_assignees".to_sym,
        through: :assignments,
        source: :assignee,
        source_type: type
  end

  def assignees
    (company_assignees + group_assignees + user_assignees)
  end
end

类问题

---

这将只导致每个受让人类型有一个查询，这是一个很大的改进。

在这种情况下，我将添加一个分配模型，作为问题和分配给它的实体之间的交叉点

创建表 让我们运行生成器来创建所需的文件：

rails g模型分配问题：属于\u受让人\u id:integer受让人\u类型：字符串

然后，让我们打开创建的迁移文件

（db/migrations/…\uu create\u assignments.rb）

：

polymorpic:true

选项告诉ActiveRecord查看

assignment\u type

列以决定从哪个表加载

assignment

class User < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

class Group < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end    

class Company < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

但这会导致非常低效的SQL查询，因为每个受让人都将被加载到一个查询中

相反，您可以这样做：

class Question < ActiveRecord::Base
  has_many :assignments

  # creates a relationship for each assignee type
  ['Company', 'Group', 'User'].each do |type|
    has_many "#{type.downcase}_assignees".to_sym,
        through: :assignments,
        source: :assignee,
        source_type: type
  end

  def assignees
    (company_assignees + group_assignees + user_assignees)
  end
end

类问题

---

这将只导致每个受让人类型有一个查询，这是一个很大的改进。

在这种情况下，我将添加一个分配模型，作为问题和分配给它的实体之间的交叉点

创建表 让我们运行生成器来创建所需的文件：

rails g模型分配问题：属于\u受让人\u id:integer受让人\u类型：字符串

然后，让我们打开创建的迁移文件

（db/migrations/…\uu create\u assignments.rb）

：

polymorpic:true

选项告诉ActiveRecord查看

assignment\u type

列以决定从哪个表加载

assignment

class User < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

class Group < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end    

class Company < ActiveRecord::Base
  has_many :assignments, as: :assignee
  has_many :questions, through: :assignments
end

但这会导致非常低效的SQL查询，因为每个受让人都将被加载到一个查询中

相反，您可以这样做：

class Question < ActiveRecord::Base
  has_many :assignments

  # creates a relationship for each assignee type
  ['Company', 'Group', 'User'].each do |type|
    has_many "#{type.downcase}_assignees".to_sym,
        through: :assignments,
        source: :assignee,
        source_type: type
  end

  def assignees
    (company_assignees + group_assignees + user_assignees)
  end
end

类问题

这将只导致每种类型的一个查询，这是一个很大的改进