How can I populate a join (many-to-many) table inside seeds.rb for ruby on rails?

rails many-to-many
seed join table
activerecord many to many join table
rails many to many to many
rails g many to many
many-to-many migration rails
rails many-to-many query
rails many-to-many controller

I currently have a model for team.rb and user.rb, which is a many to many relationship. I have created the join table teams_users but I am not sure how to populate this table in my seeds.rb?

For example, I have :

user = User.create({ first_name: 'Kamil', last_name: 'Bo', email: 'bo@gmail.com'})
team = Team.create([{ name: 'Spot Forwards', num_of_games: 10, day_of_play: 4}])

But the following does not work???

TeamsUsers.create({ team_id: team.id, user_id: user.id })

I get a message :

uninitialized constant TeamsUsers

This isn't optimized but

user.team_ids = user.team_ids < team.id
user.save

or if this is the first team

user.team_ids = [team.id]
user.save

ALso start using has_many :through. then you will have a TeamUser model. it's a life saver if the join table needs more attributes

4.5. Populating the Database with seeds.rb, rb , the Rails gods have given us a way of feeding default values easily and quickly to a fresh installation. This is a normal Ruby program within the Rails  The application is a mockup of an educational site in Rails 3.2.19. There is a Courses model, a Students model, and an Awards model. I am trying to populate with a few records, but I can't seem to

Pick a side to work from and then, as @drhenner suggests, use the _ids property to create the association. For example, working with the User model, create the teams first, then the users, assigning them to teams as you go:

teams = Team.create([
  { name: 'Team 1' },
  { name: 'Team 2' },
  { name: 'Team 3' },

  # etc.
])

User.create([
  { name: 'User 1', team_ids: [teams[0].id, teams[2].id] },
  { name: 'User 2', team_ids: [teams[1].id, teams[2].id] },
  { name: 'User 3', team_ids: [teams[0].id, teams[1].id] },

  # etc.
])

From comment above:

You can have multiple relationships configured on a has_many :through relationship. It's up to you which ones you want to implement. These are all the possibilities:

class Team < ApplicationRecord
  has_many :memberships
  has_many :users, through: :memberships
end

class Membership < ApplicationRecord
  belongs_to :team
  belongs_to :user
end

class User < ApplicationRecord
  has_many :memberships
  has_many :teams, through: :memberships
end

So, when dealing with the Team model, you can use: team.memberships and team.users;

when dealing with the User model, you can use: user.memberships and user.teams;

and if dealing with the join model, you can use: membership.team and membership.user.


You can omit the relationship references to the join model if you don't use it—especially if you're treating the relationship between Team and User like a standard has_and_belongs_to_many relationship:

class Team < ApplicationRecord
  has_many :users, through: :memberships
end

class User < ApplicationRecord
  has_many :teams, through: :memberships
end

This gives you team.users and user.teams.

Self referencing tables and making friends with Ruby on Rails., A playlist has many songs and songs belong to many playlists. Welcome to my self-referencing tables using Ruby on Rails blog! need two Models — The User Model and the Follow Model that will serve as the "join" table. Run rake db:​reset to empty the database; In your db/seeds.rb file pase the following: This will  Populating the Database with seeds.rb With the file db/seeds.rb , the Rails gods have given us a way of feeding default values easily and quickly to a fresh installation. This is a normal Ruby program within the Rails environment.

Using Rails, say you have tables foos and bars in a many-to-many relationship using table foos_bars, you can seed their associations like this:

bar1 = Bar.find(1)
bar2 = Bar.find(2)

foo1 = Foo.find(1) # for example
foo1.bars << bar1
foo1.bars << bar2
foo1.save

This will update the joins table foos_bars with associations <foo_id:1, bar_id:1>, <foo_id:1, bar_id:2>

Hope this helps.

Convert a belongs_to Association to a has_many :through , rails new association-converter --database=postgresql cd Install Faker and seed the database with sample data. Add gem In the def up method populate the new join table with the existing associate book with author, even though it will just be one. The schema.rb should look similar to the following:. Once you have some code in seeds.rb to generate data, you can populate your database from the terminal: There are even great Ruby gems like the Faker gem for creating more realistic dummy data such as names, colors, and URLs.

Chapter 2. Create a Rails Application · Ruby On Rails Tutorial, Method · 2.7 .all Method · 2.8 .join Method In this Chapter, we are going to create a sample Ruby on Rails application. A model, view, and controller will be generated in just one line of code. Figure 2.6.3 shows Posts table is populated and matched with the data in seeds.rb as shown in Figure 2.6.1. Step-by-step instructional for creating a Ruby on Rails app that implements a self-join, then triple-join relationship many-to-many, and many-to-many self-join Our join table has been

Active Record Migrations, Creating a Table; Creating a Join Table; Changing Tables; Changing Columns Active Record and Referential Integrity; Migrations and Seed Data Active Record will also update your db/schema.rb file to match the up-to-date Migrations are stored as files in the db/migrate directory, one for each migration class. For the Many-To-Many, you don't have 36 options : you actually have 2 : Array of IDs on One side like you did Array of IDs on Both sides. The cool thing with the Ruby-on-rails - Mongodb many to many without join table

Testing Rails Applications, The default test stub in test/models/article_test.rb looks like this: Every test may contain one or more assertions, with no restriction as to how Fixtures allow you to populate your testing database with predefined data before your tests run. the fixture data into the table; Dump the fixture data into a method in case you  Self referencing tables and making friends with Ruby on Rails. I was able to setup the relations between my models’ many-to-many relationships. With the tracklist serving as the join

Comments
  • Would I put a has_many :through on both the team and the user?
  • It's up to you. See my post below.