Ruby on Rails
ActiveRecord
Recherche…
Créer un modèle manuellement
Bien que l'utilisation de l'échafaudage soit rapide et facile si vous débutez dans Rails ou si vous créez une nouvelle application, il peut être utile de le faire tout seul pour éviter le besoin de parcourir le code généré par l'échafaudage (retirez les pièces inutilisées, etc.).
Créer un modèle peut être aussi simple que de créer un fichier sous app/models
.
Le modèle le plus simple, dans ActiveRecord
, est une classe qui étend ActiveRecord::Base
.
class User < ActiveRecord::Base
end
Les fichiers modèles sont stockés dans app/models/
et le nom du fichier correspond au nom singulier de la classe:
# user
app/models/user.rb
# SomeModel
app/models/some_model.rb
La classe héritera de toutes les fonctionnalités d'ActiveRecord: méthodes de requête, validations, rappels, etc.
# Searches the User with ID 1
User.find(1)
Remarque: Assurez-vous que la table du modèle correspondant existe. Sinon, vous pouvez créer la table en créant une migration
Vous pouvez générer un modèle et sa migration par terminal à partir de la commande suivante
rails g model column_name1:data_type1, column_name2:data_type2, ...
et peut également affecter une clé étrangère (relation) au modèle en suivant la commande
rails g model column_name:data_type, model_name:references
Créer un modèle via un générateur
Ruby on Rails fournit un générateur de model
vous pouvez utiliser pour créer des modèles ActiveRecord. Utilisez simplement des rails generate model
et indiquez le nom du modèle.
$ rails g model user
En plus du fichier modèle dans les app/models
, le générateur créera également:
- le test dans
test/models/user_test.rb
- les Fixtures dans
test/fixtures/users.yml
- la migration de la base de données dans
db/migrate/XXX_create_users.rb
Vous pouvez également générer des champs pour le modèle lors de sa génération.
$ rails g model user email:string sign_in_count:integer birthday:date
Cela créera les colonnes email, sign_in_count et birthday dans votre base de données, avec les types appropriés.
Créer une migration
Ajouter / supprimer des champs dans des tables existantes
Créez une migration en exécutant:
rails generate migration AddTitleToCategories title:string
Cela créera une migration qui ajoutera une colonne de title
à une table de categories
:
class AddTitleToCategories < ActiveRecord::Migration[5.0]
def change
add_column :categories, :title, :string
end
end
De même, vous pouvez générer une migration pour supprimer une colonne: rails generate migration RemoveTitleFromCategories title:string
Cela créera une migration qui supprime une colonne de title
de la table des categories
:
class RemoveTitleFromCategories < ActiveRecord::Migration[5.0]
def change
remove_column :categories, :title, :string
end
end
Bien que, à proprement parler, la spécification du type ( :string
dans ce cas) ne soit pas nécessaire pour supprimer une colonne, elle est utile , car elle fournit les informations nécessaires pour la restaurer .
Créer une table
Créez une migration en exécutant:
rails g CreateUsers name bio
Rails reconnaît l'intention de créer une table à partir du préfixe Create
, le reste du nom de la migration sera utilisé comme nom de table. L'exemple donné génère les éléments suivants:
class CreateUsers < ActiveRecord::Migration
def change
create_table :users do |t|
t.string :name
t.string :bio
end
end
end
Notez que la commande de création n'a pas spécifié les types de colonnes et que la string
par défaut a été utilisée.
Créer une table de jointure
Créez une migration en exécutant:
rails g CreateJoinTableParticipation user:references group:references
Rails détecte l'intention de créer une table de jointure en recherchant JoinTable
dans le nom de la migration. Tout le reste est déterminé à partir des noms des champs que vous donnez après le nom.
class CreateJoinTableParticipation < ActiveRecord::Migration
def change
create_join_table :users, :groups do |t|
# t.index [:user_id, :group_id]
# t.index [:group_id, :user_id]
end
end
end
Décommentez les instructions d' index
nécessaires et supprimez le reste.
Priorité
Notez que l'exemple de nom de migration CreateJoinTableParticipation
correspond à la règle de création de table: il comporte un préfixe Create
. Mais il n'a pas généré de simple create_table
. En effet, le générateur de migration ( code source ) utilise une première correspondance de la liste suivante:
(Add|Remove)<ignored>(To|From)<table_name>
<ignored>JoinTable<ignored>
Create<table_name>
Introduction aux rappels
Un rappel est une méthode appelée à des moments spécifiques du cycle de vie d'un objet (juste avant ou après la création, la suppression, la mise à jour, la validation, l'enregistrement ou le chargement depuis la base de données).
Par exemple, disons que vous avez une liste qui expire dans les 30 jours suivant sa création.
Une façon de faire est comme ceci:
class Listing < ApplicationRecord
after_create :set_expiry_date
private
def set_expiry_date
expiry_date = Date.today + 30.days
self.update_column(:expires_on, expiry_date)
end
end
Toutes les méthodes disponibles pour les rappels sont les suivantes, dans l’ordre dans lequel elles sont appelées pendant le fonctionnement de chaque objet:
Créer un objet
- before_validation
- after_validation
- avant_save
- autour_save
- avant_créer
- around_create
- after_create
- après_save
- after_commit / after_rollback
Mise à jour d'un objet
- before_validation
- after_validation
- avant_save
- autour_save
- avant_update
- autour_update
- after_update
- après_save
- after_commit / after_rollback
Détruire un objet
- before_destroy
- around_destroy
- after_destroy
- after_commit / after_rollback
REMARQUE: after_save s'exécute à la fois sur create et update, mais toujours après les rappels plus spécifiques after_create et after_update, quel que soit l'ordre dans lequel les appels de macros ont été exécutés.
Créer une table de jointure à l'aide de Migrations
Particulièrement utile pour la relation has_and_belongs_to_many
, vous pouvez créer manuellement une table de jointure à l'aide de la méthode create_table
. Supposons que vous ayez deux modèles, Tags
et Proyects
, et que vous souhaitez les associer en utilisant une relation has_and_belongs_to_many
. Vous avez besoin d'une table de jointure pour associer des instances des deux classes.
class CreateProjectsTagsJoinTableMigration < ActiveRecord::Migration
def change
create_table :projects_tags, id: false do |t|
t.integer :project_id
t.integer :tag_id
end
end
end
Le nom réel de la table doit suivre cette convention: le modèle qui précède l’autre alphabétiquement doit passer en premier. P rojet preceds T ags de sorte que le nom de la table est projects_tags.
De plus, l'objectif de cette table étant de router l'association entre les instances de deux modèles, l'ID réel de chaque enregistrement de cette table n'est pas nécessaire. Vous spécifiez ceci en passant id: false
Enfin, comme c'est la convention dans Rails, le nom de la table doit être la forme plurielle composée des modèles individuels, mais la colonne de la table doit être au singulier.
Test manuel de vos modèles
Tester vos modèles Active Record via votre interface de ligne de commande est simple. Accédez au répertoire de l'application dans votre terminal et tapez dans la rails console
pour démarrer la console Rails. De là, vous pouvez exécuter des méthodes d'enregistrement actives sur votre base de données.
Par exemple, si vous aviez un schéma de base de données avec une table Users portant un name:string
colonne et email:string
, vous pourriez exécuter:
User.create name: "John", email: "[email protected]"
Ensuite, pour afficher cet enregistrement, vous pouvez exécuter:
User.find_by email: "[email protected]"
Ou, s'il s'agit de votre premier ou de votre seul enregistrement, vous pouvez simplement obtenir le premier enregistrement en exécutant:
User.first
Utilisation d'une instance de modèle pour mettre à jour une ligne
Disons que vous avez un modèle d' User
class User < ActiveRecord::Base
end
Maintenant, pour mettre à jour le first_name
et le last_name
d'un utilisateur avec id = 1
, vous pouvez écrire le code suivant.
user = User.find(1)
user.update(first_name: 'Kashif', last_name: 'Liaqat')
L'appel de update
à jour tentera de mettre à jour les attributs donnés dans une transaction unique, renvoyant true
si l'opération réussit et false
si ce n'est pas le cas.