I use ** rails db: migrate ** as a matter of course in Rails, but I think there are some people who use it somehow and don't know what they are actually doing.
Until recently, I somehow understood that ** ah migration files are reflected in the database ~ **.
However, as I studied deeply, I wondered, "What are each Rails command doing after all?", So I summarized it in this article.
From the conclusion ** migrate is the act of reflecting the contents of the migration file in the DB ** Will be.
However, this alone is weak, so I will dig a little deeper.
First of all, the basic recognition part, the framework called Ruby on Rails uses a model called MVC.
I will omit the details here, but
--Execute action in response to request from server ** Controller ** --Exchange with database (DB) ** Model ** rails g model --** View ** responsible for browser display
It consists of three parts.
rails g model
Before understanding migration, let's start with the model creation command.
When you execute the rails g model command, two types of files, a model file and a migration file, are created (strictly speaking, a test file etc. are also created automatically).
Each of these files
--migration file → Contents to be changed to DB --model file → Connect DB and Rails application
There is such a role.
In particular, all the models created here inherit the class called ApplicationRecord.
class User < ApplicationRecord # Include default devise modules. Others available are: # :confirmable, :lockable, :timeoutable, :trackable and :omniauthable end
In addition, the parent class of this ApplicationRecord class inherits from ActiveRecord :: Base.
class ApplicationRecord < ActiveRecord::Base self.abstract_class = true end
This ActiveRecord class has the ability to translate the SQL syntax needed to interact with the DB.
Therefore, ** you can easily access the DB and tamper with the data without writing SQL syntax each time **.
You may not be familiar with it when you enter from Rails, but in order to access the DB and manipulate the data, you usually have to skip the instructions using another language called SQL **.
SQL statement example
--Create table CREATE TABLE USERS ( ID INT NOT NULL PRIMARY KEY, NAME VARCHAR NOT NULL AGE INT NOT NULL ); --Create data(table in rails.create(value1, value2…)) INSERT INTO USERS VALUES (1,'Ichihara',''); --Select all data(In rails model.all) SELECT * FROM USERS
However, Rails can use this ** ActiveRecord ** to automatically translate it into SQL and operate the DB ** with a more intuitive and simple syntax.
Also, since getters and setters are automatically defined in this ActiveRecord :: Base class, you can refer to the instance value ** without intentionally defining ** attr_accessor etc.
I see… It's certainly convenient, but what made it difficult to understand getters and setters ...
Make changes to the DB based on the migration file created by running rails db: migrate. In this case, a new table is created on the DB for migrate when creating the model.
class CreateUsers < ActiveRecord::Migration[5.1] def change create_table :users do |t| t.string :name t.timestamps end end end
The table created by ActiveRecord has the following characteristics.
--Table name is plural of model (Post → posts) --id, created_at are automatically created
By the way, if you create a migration file with ** rails g migration **, the change method is automatically defined and you can make changes to the already created table.
class PasswordDigestToUsers < ActiveRecord::Migration[5.1] def change add_column :users, :password_digest, :string end end
That's all about migration.
I'm not very confident, so I'd appreciate it if you could point out any mistakes in Lee's commentary!