Ruby on Rails
Active

Skapa en modell manuellt

Medan användning av byggnadsställning är snabbt och enkelt om du är ny med Rails eller om du skapar en ny applikation kan det senare vara användbart bara för att göra det på egen hand och undvika behovet av att gå igenom den byggnadsställningsgenererade koden för att smala den (ta bort oanvända delar etc.).

Att skapa en modell kan vara lika enkelt som att skapa en fil under app/models .

Den mest enkla modellen i ActiveRecord är en klass som utvidgar ActiveRecord::Base .

class User < ActiveRecord::Base
end

Modelfiler lagras i app/models/ , och filnamnet motsvarar klassens enskilda namn:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

Klassen ärver alla ActiveRecord-funktioner: frågeställningar, valideringar, återuppringningar etc.

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

Obs: Se till att tabellen för motsvarande modell finns. Om inte kan du skapa tabellen genom att skapa en migrering

Du kan generera en modell och dess migrering via terminal från följande kommando

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

och kan också tilldela utländsk nyckel (relation) till modellen genom att följa kommandot

rails g model column_name:data_type, model_name:references

Skapa en modell via generator

Ruby on Rails tillhandahåller en model du kan använda för att skapa ActiveRecord-modeller. Använd bara rails generate model och ange modellnamnet.

$ rails g model user

Utöver modellfilen i app/models kommer generatorn också att skapa:

• testet i test/models/user_test.rb
• fixturer i test/fixtures/users.yml
• databasen Migration i db/migrate/XXX_create_users.rb

Du kan också generera några fält för modellen när du genererar den.

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

Detta skapar kolumnerna e-post, sign_in_count och födelsedag i din databas med lämpliga typer.

Skapa en migration

Lägg till / ta bort fält i befintliga tabeller

Skapa en migrering genom att köra:

rails generate migration AddTitleToCategories title:string

Detta kommer att skapa en migration som lägger till en title kolumn i en categories tabell:

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

På liknande sätt kan du generera en migrering för att ta bort en kolumn: rails generate migration RemoveTitleFromCategories title:string

Detta kommer att skapa en migrering som tar bort en title kolumn från categories tabell:

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

Även om det inte är nödvändigt att specificera typ ( :string i detta fall) för att ta bort en kolumn, är det bra eftersom det ger den information som krävs för att rulla tillbaka den .

Skapa en tabell

Skapa en migrering genom att köra:

rails g CreateUsers name bio

Rails känner igen avsikten att skapa en tabell från prefixet Create , resten av migrationsnamnet kommer att användas som tabellnamn. Det givna exemplet genererar följande:

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

Lägg märke till att kommandot skapelsen inte specificera typer av kolonner och string användes.

Skapa en sammanfogningstabell

Skapa en migrering genom att köra:

rails g CreateJoinTableParticipation user:references group:references

Rails upptäcker avsikten att skapa en sammanfogningstabell genom att hitta JoinTable i migrationsnamnet. Allt annat bestäms utifrån namnen på fälten du anger efter namnet.

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

Avkommentera nödvändiga index uttalanden och radera resten.

Företräde

Lägg märke till att CreateJoinTableParticipation stämmer CreateJoinTableParticipation med regeln för tabellskapande: det har ett Create prefix. Men det genererade inte en enkel create_table . Detta beror på att migreringsgenerator ( källkod ) använder en första matchning i följande lista:

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

• <ignored>JoinTable<ignored>

• Create<table_name>

Introduktion till återuppringningar

En återuppringning är en metod som blir anropad vid specifika ögonblick i ett objekts livscykel (precis före eller efter skapandet, radering, uppdatering, validering, spara eller laddning från databasen).

Säg till exempel att du har en lista som går ut inom 30 dagar efter skapandet.

Ett sätt att göra det är så här:

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

Alla tillgängliga metoder för återuppringning är följande, i samma ordning som de anropas under driften av varje objekt:

Skapa ett objekt

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

Uppdatera ett objekt

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

Förstör ett objekt

• before_destroy
• around_destroy
• after_destroy
• after_commit / after_rollback

OBS: after_save körs både vid skapa och uppdatera, men alltid efter de mer specifika återuppringningarna after_create och after_update, oavsett i vilken ordning makroanropen utfördes.

Skapa en anslutningstabell med migreringar

Speciellt användbart för has_and_belongs_to_many relation, du kan skapa en sammanfogningstabell create_table metoden create_table . Anta att du har två modeller Tags och Proyects , och du vill associera dem med en has_and_belongs_to_many relation. Du behöver en sammanfogningstabell för att associera instanser av båda klasserna.

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

Tabellens faktiska namn måste följa denna konvention: modellen som alfabetiskt föregår den andra måste gå först. P roject föregår T ags så namnet på tabellen är projects_tags.

Eftersom syftet med denna tabell är att dirigera sambandet mellan förekomsten av två modeller, är den verkliga id för varje post i denna tabell inte nödvändig. Du anger detta genom att skicka id: false

Slutligen, såsom är konventionen i Rails, måste tabellnamnet vara den sammansatta pluralformen för de enskilda modellerna, men kolumnen i tabellen måste vara i singularform.

Testa dina modeller manuellt

Testa dina Active Record-modeller via ditt kommandoradgränssnitt är enkelt. Navigera till appkatalogen i din terminal och skriv in rails console att starta Rails-konsolen. Härifrån kan du köra aktiva inspelningsmetoder i din databas.

Om du till exempel hade ett databasschema med en tabell Användare med ett name:string och email:string , kan du köra:

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

Sedan, för att visa den posten, kan du köra:

User.find_by email: "[email protected]"

Eller om detta är din första eller enda post, kan du helt enkelt få den första posten genom att köra:

User.first

Använda en modellinstans för att uppdatera en rad

Låt oss säga att du har en User

class User < ActiveRecord::Base
end

first_name att uppdatera first_name och last_name för en användare med id = 1 kan du skriva följande kod.

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

update samtalen försöker uppdatera de givna attributen i en enda transaktion, och returnerar true om det är framgångsrikt och false om inte.