Ruby on Rails
ActiveRecord

Creazione manuale di un modello

L'utilizzo di scaffolding è rapido e semplice se si è nuovi a Rails o si sta creando una nuova applicazione, in seguito può essere utile solo eseguirlo da solo per evitare la necessità di passare attraverso il codice generato dallo scaffold per ridurlo. (rimuovere le parti non utilizzate, ecc.).

La creazione di un modello può essere semplice come creare un file in app/models .

Il modello più semplice, in ActiveRecord , è una classe che estende ActiveRecord::Base .

class User < ActiveRecord::Base
end

I file di modello sono memorizzati in app/models/ e il nome del file corrisponde al nome singolare della classe:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

La classe erediterà tutte le funzionalità di ActiveRecord: metodi di interrogazione, convalide, callback, ecc.

# Searches the User with ID 1
User.find(1)

Nota: assicurarsi che la tabella per il modello corrispondente esista. In caso contrario, è possibile creare la tabella creando una migrazione

È possibile generare un modello ed è la migrazione per terminale dal seguente comando

rails g model column_name1:data_type1, column_name2:data_type2, ...

e può anche assegnare una chiave esterna (relazione) al modello seguendo il comando

rails g model column_name:data_type, model_name:references

Creazione di un modello tramite generatore

Ruby on Rails fornisce un generatore di model che è possibile utilizzare per creare modelli ActiveRecord. Basta usare i rails generate model e fornire il nome del modello.

$ rails g model user

Oltre al file di modello in app/models , il generatore creerà anche:

• il test in test/models/user_test.rb
• le Fixtures in test/fixtures/users.yml
• la migrazione del database in db/migrate/XXX_create_users.rb

È anche possibile generare alcuni campi per il modello quando lo si genera.

$ rails g model user email:string sign_in_count:integer birthday:date

Questo creerà le colonne email, sign_in_count e birthday nel tuo database, con i tipi appropriati.

Creazione di una migrazione

Aggiungi / rimuovi campi nelle tabelle esistenti

Crea una migrazione eseguendo:

rails generate migration AddTitleToCategories title:string

Ciò creerà una migrazione che aggiunge una colonna del title a una tabella delle categories :

class AddTitleToCategories < ActiveRecord::Migration[5.0]
  def change
    add_column :categories, :title, :string
  end
end

Allo stesso modo, è possibile generare una migrazione per rimuovere una colonna: le rails generate migration RemoveTitleFromCategories title:string

Ciò creerà una migrazione che rimuove una colonna del title dalla tabella delle categories :

class RemoveTitleFromCategories < ActiveRecord::Migration[5.0]
  def change
    remove_column :categories, :title, :string
  end
end

Mentre, in senso stretto, non è necessario specificare il tipo ( :string in questo caso) per rimuovere una colonna, è utile , poiché fornisce le informazioni necessarie per il rollback .

Crea un tavolo

Crea una migrazione eseguendo:

rails g CreateUsers name bio

Rails riconosce l'intenzione di creare una tabella dal prefisso Create , il resto del nome della migrazione verrà utilizzato come nome di tabella. L'esempio fornito genera quanto segue:

class CreateUsers < ActiveRecord::Migration
  def change
    create_table :users do |t|
      t.string :name
      t.string :bio
    end
  end
end

Si noti che il comando di creazione non ha specificato tipi di colonne e string stata utilizzata la string predefinita.

Crea una tabella di join

Crea una migrazione eseguendo:

rails g CreateJoinTableParticipation user:references group:references

Rails rileva l'intento di creare una tabella di join trovando JoinTable nel nome della migrazione. Tutto il resto è determinato dai nomi dei campi che dai dopo il nome.

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

Decommentare le dichiarazioni index necessarie e cancellare il resto.

Precedenza

Si noti che il nome di migrazione di esempio CreateJoinTableParticipation corrisponde alla regola per la creazione della tabella: ha un prefisso Create . Ma non ha generato un semplice create_table . Questo perché il generatore di migrazione ( codice sorgente ) utilizza una prima corrispondenza dell'elenco seguente:

• (Add|Remove)<ignored>(To|From)<table_name>

• <ignored>JoinTable<ignored>

• Create<table_name>

Introduzione ai callback

Un callback è un metodo che viene richiamato in momenti specifici del ciclo di vita di un oggetto (subito prima o dopo la creazione, la cancellazione, l'aggiornamento, la convalida, il salvataggio o il caricamento dal database).

Ad esempio, supponiamo di avere un elenco che scade entro 30 giorni dalla creazione.

Un modo per farlo è così:

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

Tutti i metodi disponibili per le richiamate sono i seguenti, nello stesso ordine in cui vengono chiamati durante l'operazione di ciascun oggetto:

Creare un oggetto

• before_validation
• after_validation
• before_save
• around_save
• before_create
• around_create
• after_create
• after_save
• after_commit / after_rollback

Aggiornamento di un oggetto

• before_validation
• after_validation
• before_save
• around_save
• before_update
• around_update
• after_update
• after_save
• after_commit / after_rollback

Distruggere un oggetto

• before_destroy
• around_destroy
• after_destroy
• after_commit / after_rollback

NOTA: after_save viene eseguito sia su create che su update, ma sempre dopo i callback più specifici after_create e after_update, indipendentemente dall'ordine in cui sono state eseguite le macro chiamate.

Creare una tabella di join utilizzando le migrazioni

Particolarmente utile per la relazione has_and_belongs_to_many , è possibile creare manualmente una tabella di join utilizzando il metodo create_table . Supponiamo che tu abbia due modelli Tags e Proyects e desideri associarli usando una relazione has_and_belongs_to_many . È necessaria una tabella di join per associare le istanze di entrambe le classi.

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

Il nome effettivo della tabella deve seguire questa convenzione: il modello che precede alfabeticamente l'altro deve prima passare. P roject precede T ags quindi il nome della tabella è project_tags.

Inoltre, poiché lo scopo di questa tabella è quello di instradare l'associazione tra le istanze di due modelli, l'ID effettivo di ogni record in questa tabella non è necessario. Si specifica questo passando id: false

Infine, come è convenzione in Rails, il nome della tabella deve essere la forma plurale composta dei singoli modelli, ma la colonna della tabella deve essere in forma singolare.

Testare manualmente i tuoi modelli

Testare i modelli di record attivi tramite l'interfaccia della riga di comando è semplice. Passare alla directory dell'app nel terminale e digitare nella rails console per avviare la console di Rails. Da qui, puoi eseguire metodi di registrazione attivi sul tuo database.

Ad esempio, se si dispone di uno schema di database con una tabella Utenti con un name:string colonna di name:string e email:string , è possibile eseguire:

User.create name: "John", email: "[email protected]"

Quindi, per mostrare quel record, puoi eseguire:

User.find_by email: "[email protected]"

O se questo è il tuo primo o unico record, puoi semplicemente ottenere il primo record eseguendo:

User.first

Utilizzando un'istanza di modello per aggiornare una riga

Supponiamo tu abbia un modello User

class User < ActiveRecord::Base
end

Ora per aggiornare il first_name e il last_name di un utente con id = 1 , puoi scrivere il seguente codice.

user = User.find(1)
user.update(first_name: 'Kashif', last_name: 'Liaqat')

La chiamata update tenterà di aggiornare gli attributi dati in una singola transazione, restituendo true se ha esito positivo e false caso contrario.