La création d'une relation plusieurs-à-plusieurs dans les Rails

C'est un exemple simplifié de ce que je suis en train de réaliser, je suis relativement nouveau sur les Rails et je suis mal à obtenir ma tête autour des relations entre les modèles.

J'ai deux modèles, la User modèle et la Category modèle. Un utilisateur peut être associé à de nombreuses catégories. Une catégorie particulière peut apparaître dans la liste des catégories pour de nombreux utilisateurs. Si une catégorie est supprimée, cela devrait être reflété dans la liste des catégories pour un utilisateur.

Dans cet exemple:

Mon Categories table contient cinq catégories:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
| ID | Nom | 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
| 1 | Sport | 
| 2 | Nouvelles | 
| 3 | Divertissement | 
| 4 | Technologie | 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Mon Users table contient deux utilisateurs:

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
| ID | Nom | 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
| 1 | UserA | 
| 2 | UserB | 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

L'utilisateur peut choisir de Sport et de la Technologie dans ses catégories

L'utilisateur b peut choisir de Nouvelles, de Sports et de Divertissement

La catégorie sports est supprimé, à la fois l'Utilisateur a et utilisateur b catégorie des listes de tenir compte de la suppression

J'ai joué avec la création d'un UserCategories table qui contient l'id d'une catégorie et de l'utilisateur. Ce genre de travaillé, j'ai pu regarder jusqu'à la catégorie des noms, mais je ne pouvais pas obtenir une suppression en cascade de travail et l'ensemble de la solution semblait mal.

Les exemples d'utilisation de l'belongs_to et has_many fonctions que j'ai trouvé semble pour discuter de la cartographie d'un one-to-one relation. Par exemple, des commentaires sur un blog.

Comment représentez-vous ce plusieurs-à-plusieurs relations en utilisant le haut-dans les Rails de la fonctionnalité?
Est à l'aide d'un tableau distinct entre les deux une solution viable lors de l'utilisation de Rails?

En fait, il n'y a rien de mal à utiliser le UserCategory modèle, il est même souhaitable dans la plupart des cas. Vous avez juste besoin d'utiliser User.has_many :categories, through: :user_categories. Peut-être, un meilleur nom pourrait être trouvées.
Pour les autres, il y a un bon rails en fonte, ici, sur le sujet: railscasts.com/episodes/47-two-many-to-many

InformationsquelleAutor fletcher | 2011-02-25

ruby-on-rails

135

Vous voulez un has_and_belongs_to_many relation. Le guide fait un excellent travail en décrivant comment cela fonctionne avec les cartes et tout et tout:

http://guides.rubyonrails.org/association_basics.html#the-has-and-belongs-to-many-association

Vous allez vous retrouver avec quelque chose comme ceci:
```
# app/models/category.rb
class Category < ActiveRecord::Base
  has_and_belongs_to_many :users
end

# app/models/user.rb
class User < ActiveRecord::Base
  has_and_belongs_to_many :categories
end
```
Vous devez maintenant créer une table de jointure pour les Rails à utiliser. Rails de ne pas faire cela automatiquement pour vous. C'est effectivement un tableau avec une référence à chacune des Catégories et les Utilisateurs, et pas de clé primaire.

Générer une migration à partir de la CLI comme ceci:
```
bin/rails g migration CreateCategoriesUsersJoinTable
```
Puis l'ouvrir et le modifier pour correspondre à:

Pour les Rails 4.0.2+ (y compris les Rails 5.2):
```
def change
  # This is enough; you don't need to worry about order
  create_join_table :categories, :users

  # If you want to add an index for faster querying through this join:
  create_join_table :categories, :users do |t|
    t.index :category_id
    t.index :user_id
  end
end
```
Rails < 4.0.2:
```
def self.up
  # Model names in alphabetical order (e.g. a_b)
  create_table :categories_users, :id => false do |t|
    t.integer :category_id
    t.integer :user_id
  end

  add_index :categories_users, [:category_id, :user_id]
end

def self.down
  drop_table :categories_users
end
```
Avec que en place, d'exécuter les migrations et vous pouvez vous connecter Catégories et les Utilisateurs avec l'ensemble de la pratique des accesseurs vous en avez l'habitude:
```
User.categories  #=> [<Category @name="Sports">, ...]
Category.users   #=> [<User @name="UserA">, ...]
User.categories.empty?
```
- Une autre astuce: créer un indice composite de la table. Plus ici stackoverflow.com/a/4381282/14540
- Grand point; j'ai ajouté à l'exemple ici pour le plaisir d'être approfondie. Cheers!
- question stupide, est-ce à dire qu'il est nécessaire de créer un nouveau modèle?
- has_and_belongs_to_many n'a pas besoin/création de modèle. Si vous avez besoin de travailler directement avec la relation ou la nécessité d'ajouter des attributs à la relation, vous devez utiliser has_many :par le biais de l'option. Suivez le lien dans la réponse pour les informations détaillées.
- Une autre chose que j'ai remarqué, c'est la convention de nommage de la zone de jonction de la table. Il doit être par ordre alphabétique. En utilisant l'exemple ci-dessus, le nom de la table doit être categories_users et pas users_categories. "c" avant de "u" dans ce cas.
- Je fais cela et vous pouvez voir la jointure de table est créée dans le schéma, mais je reçois NoMethodError quand je lance User.categories etc. Les idées de ce que je pourrais être absent?
- est une méthode sur une instance de User, et non pas la classe.
- Pourquoi ne pas le categories_users table ont un id? (:id => false do |t|)
- Vous n'avez pas besoin d'une clé primaire car il n'y a qu'une seule instance de la relation entre les deux.
InformationsquelleAutor coreyward
1

Le plus populaire est " Mono-transitive de l'Association, vous pouvez faire ceci:
```
class Book < ApplicationRecord
  has_many :book_author
  has_many :author, through: :book_author
end

# in between
class BookAuthor < ApplicationRecord
  belongs_to :book
  belongs_to :author
end

class Author < ApplicationRecord
  has_many :book_author
  has_many :book, through: :book_author
end
```
Un has_many :à travers l'association est souvent utilisé pour définir un plusieurs-à-plusieurs
connexion avec un autre modèle. Cette association indique que l'
déclarant modèle peut être mis en correspondance avec zéro, une ou plusieurs instances d'une autre
modèle en procédant par l'intermédiaire d'un troisième modèle. Prenons l'exemple d'un
la pratique médicale où les patients prennent rendez-vous pour voir les médecins.
Réf.: https://guides.rubyonrails.org/association_basics.html#the-has-many-through-association

InformationsquelleAutor Darlan Dieterich
0

Juste en complément coreyward la réponse ci-dessus:
Si vous avez déjà un modèle qui dispose d'un belongs_to, has_many relation et vous souhaitez créer une nouvelle relation has_and_belongs_to_many en utilisant la même table, vous aurez besoin de:
```
rails g migration CreateJoinTableUsersCategories users categories
```
Puis,
```
rake db:migrate
```
Après, vous devez définir vos relations:

De l'utilisateur.rb:
```
class Region < ApplicationRecord
  has_and_belongs_to_many :categories
end
```
Catégorie.rb
```
class Facility < ApplicationRecord
  has_and_belongs_to_many :users
end
```
Afin de remplir la nouvelle table de jointure avec les anciennes données, vous devrez dans votre console:
```
User.all.find_each do |u|
  Category.where(user_id: u.id).find_each do |c|
    u.categories <<  c
  end
end
```
Vous pouvez soit laisser le user_id colonne et category_id colonne à partir de la Catégorie et les tables de l'Utilisateur ou de créer une migration de le supprimer.

InformationsquelleAutor B-M

Vous devez vous connecter pour publier un commentaire.

Pour les Rails 4.0.2+ (y compris les Rails 5.2):

Rails < 4.0.2: