Ruby on Rails
Aktiver Rekord

Modell manuell erstellen

Die Verwendung von Gerüsten ist schnell und einfach, wenn Sie noch nicht mit Rails vertraut sind oder wenn Sie eine neue Anwendung erstellen. Später kann es jedoch nützlich sein, dies nur auf eigene Faust zu tun, um zu vermeiden, dass Sie den durch Gerüst erzeugten Code durchlaufen müssen, um sie zu reduzieren (Entfernen Sie nicht verwendete Teile usw.).

Das Erstellen eines Modells kann so einfach sein wie das Erstellen einer Datei unter app/models .

Das einfachste Modell in ActiveRecord ist eine Klasse, die ActiveRecord::Base .

class User < ActiveRecord::Base
end

Modelldateien werden in app/models/ gespeichert und der Dateiname entspricht dem einzigen Namen der Klasse:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

Die Klasse übernimmt alle ActiveRecord-Funktionen: Abfragemethoden, Validierungen, Rückrufe usw.

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

Anmerkung: Stellen Sie sicher, dass die Tabelle für das entsprechende Modell vorhanden ist. Wenn nicht, können Sie die Tabelle erstellen, indem Sie eine Migration erstellen

Mit dem folgenden Befehl können Sie ein Modell und seine Migration nach Terminal generieren

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

und kann dem Modell auch einen Fremdschlüssel (Beziehung) mit folgendem Befehl zuweisen

rails g model column_name:data_type, model_name:references

Modell über Generator erstellen

Ruby on Rails bietet einen model , mit dem Sie ActiveRecord-Modelle erstellen können. Verwenden Sie einfach rails generate model und geben Sie den Modellnamen an.

$ rails g model user

Neben der Modelldatei in app/models der Generator außerdem:

• den Test in test/models/user_test.rb
• die Fixtures in test/fixtures/users.yml
• die Datenbank Migration in db/migrate/XXX_create_users.rb

Sie können beim Generieren auch einige Felder für das Modell generieren.

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

Dadurch werden die Spalten email, sign_in_count und birthday in Ihrer Datenbank mit den entsprechenden Typen erstellt.

Eine Migration erstellen

Felder in vorhandenen Tabellen hinzufügen / entfernen

Erstellen Sie eine Migration, indem Sie Folgendes ausführen:

rails generate migration AddTitleToCategories title:string

Dies erzeugt eine Migration , die eine fügt title zu einer categories - Tabelle:

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

Auf ähnliche Weise können Sie eine Migration zum Entfernen einer Spalte rails generate migration RemoveTitleFromCategories title:string : rails generate migration RemoveTitleFromCategories title:string

Dies erzeugt eine Migration , die einen entfernt title Spalt aus den categories Tabelle:

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

Während streng genommen Angabe Typ ( :string in diesem Fall) zum Entfernen eine Spalte nicht notwendig ist, ist es hilfreich, da es die notwendigen Informationen zum Walzen zurück zur Verfügung stellt.

Erstellen Sie eine Tabelle

Erstellen Sie eine Migration, indem Sie Folgendes ausführen:

rails g CreateUsers name bio

Rails erkennt die Absicht, eine Tabelle mit dem Präfix " Create , der Rest des Migrationsnamens wird als Tabellenname verwendet. Das gegebene Beispiel generiert Folgendes:

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

Beachten Sie, dass die Schaffung Befehl nicht Spaltentypen angeben und das Standard - string verwendet wurde.

Erstellen Sie eine Join-Tabelle

Erstellen Sie eine Migration, indem Sie Folgendes ausführen:

rails g CreateJoinTableParticipation user:references group:references

Rails erkennt die Absicht, eine Join-Tabelle zu erstellen, indem er JoinTable im Migrationsnamen findet. Alles andere wird aus den Namen der Felder bestimmt, die Sie nach dem Namen angeben.

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

Kommentar- der erforderlichen index - Anweisungen und den Rest löschen.

Vorrang

Beachten Sie, dass der Beispiel-Migrationsname CreateJoinTableParticipation der Regel für die Tabellenerstellung entspricht: Er hat das Präfix Create . Es wurde jedoch keine einfache create_table generiert. Dies liegt daran, dass der Migrationsgenerator ( Quellcode ) eine erste Übereinstimmung der folgenden Liste verwendet:

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

• <ignored>JoinTable<ignored>

• Create<table_name>

Einführung in Rückrufe

Ein Rückruf ist eine Methode, die zu bestimmten Zeitpunkten des Lebenszyklus eines Objekts aufgerufen wird (direkt vor oder nach dem Erstellen, Löschen, Aktualisieren, Überprüfen, Speichern oder Laden aus der Datenbank).

Angenommen, Sie haben eine Auflistung, die innerhalb von 30 Tagen nach der Erstellung abläuft.

Eine Möglichkeit, dies zu tun, ist wie folgt:

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 verfügbaren Methoden für Callbacks lauten in der Reihenfolge, in der sie während des Betriebs jedes Objekts aufgerufen werden:

Ein Objekt erstellen

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

Objekt aktualisieren

• before_validation
• after_validation
• before_save
• around_save
• vor_update
• around_update
• nach dem Update
• after_save
• after_commit / after_rollback

Objekt zerstören

• vor_destroy
• around_destroy
• after_destroy
• after_commit / after_rollback

HINWEIS : after_save wird sowohl beim Erstellen als auch beim Update ausgeführt, jedoch immer nach den spezifischeren Rückrufen after_create und after_update, unabhängig von der Reihenfolge, in der die Makroaufrufe ausgeführt wurden.

Erstellen Sie eine Join-Tabelle mithilfe von Migrationen

Besonders nützlich für has_and_belongs_to_many Beziehung, können Sie manuell eine Join - Tabelle mit der erstellen create_table Methode. Angenommen, Sie verfügen über zwei Modelle, Tags und Proyects , und Proyects diese mithilfe einer has_and_belongs_to_many Beziehung has_and_belongs_to_many . Sie benötigen eine Join-Tabelle, um Instanzen beider Klassen zu verknüpfen.

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

Der tatsächliche Name der Tabelle muss dieser Konvention folgen: Das Modell, das dem anderen alphabetisch vorangeht, muss zuerst gehen. P roject steht vor T ags, so dass der Name der Tabelle projects_tags lautet.

Da diese Tabelle auch dazu dient, die Zuordnung zwischen den Instanzen von zwei Modellen zu routen, ist die tatsächliche ID jedes Datensatzes in dieser Tabelle nicht erforderlich. Sie geben dies an, indem Sie id: false

Wie in Rails üblich, muss der Tabellenname schließlich die zusammengesetzte Pluralform der einzelnen Modelle sein, aber die Spalte der Tabelle muss in Singularform sein.

Manuelles Testen Ihrer Modelle

Das Testen Ihrer Active Record-Modelle über Ihre Befehlszeilenschnittstelle ist einfach. Navigieren Sie zu dem App - Verzeichnis in Ihrem Terminal und geben Sie in rails console die Rails - Konsole zu starten. Von hier aus können Sie aktive Record-Methoden in Ihrer Datenbank ausführen.

Wenn Sie beispielsweise ein Datenbankschema mit einer Users-Tabelle mit einem name:string und email:string , könnten Sie Folgendes ausführen:

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

Um diesen Datensatz anzuzeigen, können Sie Folgendes ausführen:

User.find_by email: "[email protected]"

Wenn dies Ihre erste oder einzige Aufnahme ist, können Sie einfach die erste Aufnahme abrufen, indem Sie Folgendes ausführen:

User.first

Verwenden einer Modellinstanz zum Aktualisieren einer Zeile

Angenommen, Sie haben ein User

class User < ActiveRecord::Base
end

Jetzt können Sie zum Aktualisieren des first_name und last_name eines Benutzers mit der id = 1 den folgenden Code schreiben.

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

Beim Aufruf von update wird versucht, die angegebenen Attribute in einer einzelnen Transaktion zu aktualisieren. Bei Erfolg wird true andernfalls false .