Ruby on Rails
ActiveRecord

Creando un modelo manualmente

Si bien el uso de andamios es rápido y fácil si usted es nuevo en Rails o si está creando una nueva aplicación, puede ser útil hacerlo solo para evitar la necesidad de pasar por el código generado por el andamio para reducirlo. (retire las piezas no utilizadas, etc.).

Crear un modelo puede ser tan simple como crear un archivo en app/models .

El modelo más simple, en ActiveRecord , es una clase que extiende ActiveRecord::Base .

class User < ActiveRecord::Base
end

Los archivos de modelo se almacenan en app/models/ , y el nombre del archivo corresponde al nombre singular de la clase:

# user
app/models/user.rb

# SomeModel
app/models/some_model.rb

La clase heredará todas las características de ActiveRecord: métodos de consulta, validaciones, devoluciones de llamada, etc.

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

Nota: Asegúrese de que existe la tabla para el modelo correspondiente. Si no, puede crear la tabla creando una Migración

Puede generar un modelo y su migración por terminal desde el siguiente comando

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

y también puede asignar una clave externa (relación) al modelo siguiendo el comando

rails g model column_name:data_type, model_name:references

Creando un modelo vía generador

Ruby on Rails proporciona un generador de model que puede utilizar para crear modelos ActiveRecord. Simplemente use los rails generate model y proporcionar el nombre del modelo

$ rails g model user

Además del archivo de modelo en app/models , el generador también creará:

• La prueba en test/models/user_test.rb
• los accesorios en test/fixtures/users.yml
• la migración de la base de datos en db/migrate/XXX_create_users.rb

También puede generar algunos campos para el modelo cuando lo genere.

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

Esto creará las columnas email, sign_in_count y birthday en su base de datos, con los tipos adecuados.

Creando una migración

Añadir / eliminar campos en tablas existentes

Crea una migración ejecutando:

rails generate migration AddTitleToCategories title:string

Esto creará una migración que agrega una columna de title a una tabla de categories :

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

De forma similar, puede generar una migración para eliminar una columna: los rails generate migration RemoveTitleFromCategories title:string

Esto creará una migración que elimina una columna de title de la tabla de categories :

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

Aunque, estrictamente hablando, especificar el tipo ( :string en este caso) no es necesario para eliminar una columna, es útil , ya que proporciona la información necesaria para revertirla .

Crear una tabla

Crea una migración ejecutando:

rails g CreateUsers name bio

Rails reconoce la intención de crear una tabla a partir del prefijo Create , el resto del nombre de la migración se utilizará como un nombre de tabla. El ejemplo dado genera lo siguiente:

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

Observe que el comando de creación no especificó los tipos de columnas y se usó la string predeterminada.

Crear una tabla de unión

Crea una migración ejecutando:

rails g CreateJoinTableParticipation user:references group:references

Rails detecta la intención de crear una tabla de JoinTable encontrando JoinTable en el nombre de la migración. Todo lo demás se determina a partir de los nombres de los campos que da después del nombre.

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

Descomente las declaraciones de index necesarias y elimine el resto.

Precedencia

Observe que el nombre de migración de ejemplo CreateJoinTableParticipation coincide con la regla para la creación de tablas: tiene un prefijo Create . Pero no generó un simple create_table . Esto se debe a que el generador de migración ( código fuente ) utiliza una primera coincidencia de la siguiente lista:

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

• <ignored>JoinTable<ignored>

• Create<table_name>

Introducción a las devoluciones de llamada

Una devolución de llamada es un método que recibe llamadas en momentos específicos del ciclo de vida de un objeto (justo antes o después de la creación, eliminación, actualización, validación, guardado o carga desde la base de datos).

Por ejemplo, supongamos que tiene un listado que caduca dentro de los 30 días de la creación.

Una forma de hacerlo es así:

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

Todos los métodos disponibles para las devoluciones de llamada son los siguientes, en el mismo orden en que se llaman durante la operación de cada objeto:

Creando un objeto

• validación anterior
• after_validation
• antes_save
• alrededor_save
• antes_crear
• alrededor_crear
• after_create
• after_save
• after_commit / after_rollback

Actualizando un objeto

• validación anterior
• after_validation
• antes_save
• alrededor_save
• before_update
• around_update
• después de la actualización
• after_save
• after_commit / after_rollback

Destruyendo un objeto

• antes_destroy
• alrededor_destroy
• after_destroy
• after_commit / after_rollback

NOTA: after_save se ejecuta en crear y actualizar, pero siempre después de las devoluciones de llamada más específicas after_create y after_update, sin importar el orden en que se ejecutaron las llamadas de macro.

Crear una tabla de unión usando migraciones

Especialmente útil para la relación has_and_belongs_to_many , puede crear manualmente una tabla de unión usando el método create_table . Supongamos que tiene dos modelos de Tags y Proyects , y le gustaría asociarlos utilizando una relación has_and_belongs_to_many . Necesita una tabla de unión para asociar instancias de ambas clases.

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

El nombre real de la tabla debe seguir esta convención: el modelo que precede alfabéticamente al otro debe ir primero. P roject precede a T ags por lo que el nombre de la tabla es projects_tags.

Además, dado que el propósito de esta tabla es enrutar la asociación entre las instancias de dos modelos, la identificación real de cada registro en esta tabla no es necesaria. Usted especifica esto pasando id: false

Finalmente, como es convencional en Rails, el nombre de la tabla debe ser la forma plural compuesta de los modelos individuales, pero la columna de la tabla debe estar en forma singular.

Probando manualmente tus modelos

La prueba de sus modelos de Active Record a través de su interfaz de línea de comandos es simple. Vaya al directorio de aplicaciones en su terminal y escriba la rails console de Rails para iniciar la consola de Rails. Desde aquí, puede ejecutar métodos de registro activo en su base de datos.

Por ejemplo, si tuviera un esquema de base de datos con una tabla de Usuarios con un name:string columna de name:string y email:string , podría ejecutar:

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

Entonces, para mostrar ese registro, podrías correr:

User.find_by email: "[email protected]"

O si este es su primer o único registro, simplemente puede obtener el primer registro ejecutando:

User.first

Usando una instancia de modelo para actualizar una fila

Digamos que tienes un modelo de User

class User < ActiveRecord::Base
end

Ahora para actualizar el first_name y last_name de un usuario con id = 1 , se puede escribir el siguiente código.

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

La update llamada intentará actualizar los atributos dados en una sola transacción, devolviendo true si es exitoso y false si no.