Ruby on Rails
ActiveRecord

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.