Ruby on Rails
ActiveRecord

Handmatig een model maken

Hoewel het gebruik van steigers een snel en gemakkelijk is als je nieuw bent bij Rails of een nieuwe applicatie maakt, kan het later handig zijn om het alleen te doen om te voorkomen dat je door de door de steiger gegenereerde code moet gaan om het af te slanken (verwijder ongebruikte onderdelen, etc.).

Het maken van een model kan net zo eenvoudig zijn als het maken van een bestand onder app/models .

Het meest eenvoudige model in ActiveRecord is een klasse die ActiveRecord::Base uitbreidt.

class User < ActiveRecord::Base
end

Modelbestanden worden opgeslagen in app/models/ en de bestandsnaam komt overeen met de enkelvoudige naam van de klasse:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

De klasse neemt alle ActiveRecord-functies over: querymethoden, validaties, callbacks, enz.

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

Opmerking: zorg ervoor dat de tabel voor het bijbehorende model bestaat. Als dit niet het geval is, kunt u de tabel maken door een migratie te maken

U kunt een model en de migratie per terminal genereren met de volgende opdracht

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

en kan ook een externe sleutel (relatie) aan het model toewijzen door de opdracht te volgen

rails g model column_name:data_type, model_name:references

Een model maken via een generator

Ruby on Rails biedt een model generator die u kunt gebruiken om ActiveRecord modellen te maken. Gebruik eenvoudig rails generate model en geef de modelnaam op.

$ rails g model user

Naast het modelbestand in app/models maakt de generator ook:

• de test in test/models/user_test.rb
• de test/fixtures/users.yml in test/fixtures/users.yml
• de database Migratie in db/migrate/XXX_create_users.rb

U kunt ook enkele velden voor het model genereren bij het genereren.

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

Hiermee worden de kolommen e-mail, sign_in_count en geboortedatum in uw database gemaakt, met de juiste typen.

Een migratie maken

Velden toevoegen / verwijderen in bestaande tabellen

Maak een migratie door:

rails generate migration AddTitleToCategories title:string

Dit zal een migratie die een toevoegt creëren title kolom om een categories tabel:

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

Op dezelfde manier kunt u een migratie genereren om een kolom te verwijderen: rails generate migration RemoveTitleFromCategories title:string

Dit zal een migratie die een verwijdert creëren title kolom uit de categories tabel:

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

Hoewel het specificeren van het type ( :string in dit geval) strikt genomen niet nodig is voor het verwijderen van een kolom, is het handig , omdat het de informatie biedt die nodig is om het terug te draaien .

Maak een tafel

Maak een migratie door:

rails g CreateUsers name bio

Rails herkent de intentie om een tabel te maken van het prefix Create , de rest van de migratienaam wordt gebruikt als een tabelnaam. Het gegeven voorbeeld genereert het volgende:

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

Merk op dat de creatieopdracht geen soorten kolommen specificeerde en de standaard string werd gebruikt.

Maak een join-tabel

Maak een migratie door:

rails g CreateJoinTableParticipation user:references group:references

Rails detecteert de intentie om een join-tabel te maken door JoinTable zoeken in de migratienaam. Al het andere wordt bepaald door de namen van de velden die u achter de naam opgeeft.

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

Uncomment de nodige index verklaringen en de rest weggooien.

Voorrang

Merk op dat de voorbeeldmigratienaam CreateJoinTableParticipation overeenkomt met de regel voor het maken van tabellen: deze heeft een prefix Create . Maar het genereerde geen eenvoudige create_table . Dit komt omdat de migratiegenerator ( broncode ) een eerste overeenkomst uit de volgende lijst gebruikt:

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

• <ignored>JoinTable<ignored>

• Create<table_name>

Introductie tot callbacks

Een callback is een methode die wordt aangeroepen op specifieke momenten in de levenscyclus van een object (vlak voor of na het maken, verwijderen, bijwerken, valideren, opslaan of laden uit de database).

Stel dat u een vermelding heeft die binnen 30 dagen na het maken verloopt.

Een manier om dat te doen is als volgt:

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

Alle beschikbare methoden voor callbacks zijn als volgt, in dezelfde volgorde die ze worden aangeroepen tijdens de bewerking van elk object:

Een object maken

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

Een object bijwerken

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

Een object vernietigen

• before_destroy
• around_destroy
• after_destroy
• after_commit / after_rollback

OPMERKING: after_save wordt zowel bij maken als bijwerken uitgevoerd, maar altijd na de meer specifieke callbacks after_create en after_update, ongeacht de volgorde waarin de macro-aanroepen werden uitgevoerd.

Maak een join-tabel met behulp van migraties

Speciaal nuttig voor has_and_belongs_to_many relatie, kunt u handmatig een join-tabel maken met de methode create_table . Stel dat je twee modellen Tags en Proyects en je wilt ze koppelen met behulp van een has_and_belongs_to_many relatie. U hebt een join-tabel nodig om instanties van beide klassen te koppelen.

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

De werkelijke naam van de tabel moet deze conventie volgen: het model dat alfabetisch aan het andere voorafgaat, moet eerst gaan. P roject gaat vooraf aan T ags, dus de naam van de tabel is projects_tags.

Aangezien het doel van deze tabel is om de associatie tussen de exemplaren van twee modellen te routeren, is de werkelijke id van elk record in deze tabel niet nodig. U geeft dit op door id: false

Ten slotte moet, zoals in Rails gebruikelijk is, de tabelnaam de samengestelde meervoudsvorm van de afzonderlijke modellen zijn, maar de kolom van de tabel moet in enkelvoud zijn.

Modellen handmatig testen

Het testen van uw Active Record-modellen via uw opdrachtregelinterface is eenvoudig. Navigeer naar de app-directory in uw terminal en typ rails console om de Rails-console te starten. Vanaf hier kunt u actieve opnamemethoden op uw database uitvoeren.

Als u bijvoorbeeld een databaseschema had met een tabel Gebruikers met een name:string en email:string , kunt u het volgende uitvoeren:

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

Om dat record te tonen, kun je vervolgens het volgende uitvoeren:

User.find_by email: "[email protected]"

Of als dit uw eerste of enige record is, kunt u eenvoudig het eerste record krijgen door te draaien:

User.first

Een modelinstantie gebruiken om een rij bij te werken

Stel dat u een User

class User < ActiveRecord::Base
end

Nu naar de actualiseren first_name en last_name van een gebruiker met id = 1 , kunt u de volgende code te schrijven.

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

Het aanroepen van update zal proberen om de gegeven attributen in een enkele transactie bij te werken, true teruggegeven als succesvol en false als niet.