Relaciones en Rails 3(1 1,1 n,n n)

Desarrollo web con Ruby on Rails 3ActiveRecord: asociaciones entre clases

Áncor González Sosa Imobach González Sosa

Banot.nethttp://www.banot.net/

Octubre de 2010

Áncor/Imobach GS (Banot.net) Desarrollo web con Ruby on Rails 3 Octubre de 2010 1 / 64

Contenidos1 Asociaciones: lo básico

¿Qué son?Uno a unoUno a muchosMuchos a muchosAsociaciones y consultasDependencias

2 Asociaciones: opciones destacadasIgnorando las convencionesOrdenación y límites

3 Asociaciones avanzadasPolimórficashas_many :through

4 Herencia

Los objetos no "viven" aislados

ActiveRecord ofrece mecanismos para relacionar modelosAPI potente, flexible y fácil de usarLas relaciones se declaran estilo "macro"Siguiendo las convenciones, se reduce al mínimo el código

¿Puede ser más simple?

class Artist < ActiveRecord::Basehas_many :albums

class Album < ActiveRecord::Basebelongs_to :artist

¿Puede ser más simple?

album = Album.new(:title => "Born under a bad sign")albert = Artist.find_by_name("Albert King")album.artist = albertalbert.albums.each { |a| puts a.title }

gary = Artist.find_by_name("Gary Moore")gary.albums << Album.new(:title => "King of the blues")gary.albums.build(:title => "Wild frontier")

4 Herencia

Especificación

class Company < ActiveRecord::Basehas_one :office

class Office < ActiveRecord::Basebelongs_to :company

Tablas

companiesidname string

officesidnumber stringarea integercompany_id integer

has_one

belongs_to

Referencias en las migraciones

Se puede usar el método references en la definición de tablas

create_table :offices do |t|t.string :numbert.decimal :areat.references :customer # customer_idt.timestamps

De todos modos, no deja de ser un entero:

create_table :offices do |t|t.string :numbert.decimal :areat.integer :customer_idt.timestamps

Métodos de belongs_to

association(force_reload = false)

office.company

association=(associate)

office.company = Company.first

build_association(attributes = {})

office.build_company(:name => "Banot.net")

create_association(attributes = {})

office.create_company(:name => "Inventiaplus")

Métodos de has_one

association(force_reload = false)

office.company

association=(associate)

office.company = Company.first

build_association(attributes = {})

office.build_company(:name => "Banot.net")

create_association(attributes = {})

office.create_company(:name => "Inventiaplus")

¿Cuándo se guardan los objetos?has_one

El objeto asociado se guarda al asignarlo para actualizar su claveajenaEl objeto reemplazado (si lo hubiera), también se guardaExcepto:

I Si falla una de las validaciones, se cancela la asignaciónI Si el extremo que tiene el has_one es nuevo, se esperará (a que

este se guarde)

Para asignar sin guardar, usar el método build

Si se asigna por el extremo que tiene el belongs_to, nunca seguardan los objetos

4 Herencia

Especificación

class Artist < ActiveRecord::Basehas_many :albums

class Album < ActiveRecord::Basebelongs_to :artist

Tablas

artistsidname string

albumsidtitle stringartist_id integer

has_many belongs_to

Métodos de has_many (I)

collection(force_reload = false)

artist.albums

collection<<(associate)

artist.albums << Album.new

delete(object)

artist.delete(album)

collection=(objects)

albums.class # Arrayoffice.albums = albums

Métodos de has_many (II)

collection_singular_ids / collection_singular_ids=

artist.album_ids # [1, 2]artist.album_ids = [1, 3]

artist.albums.clearartist.albums # []

empty?

artist.albums.empty?

artist.albums.size

Métodos de has_many (III)

find(...)

artist.albums.find_by_year(2010)artist.albums.find(:conditions => { ... })

artist.albums.clearartist.albums # []

exists?

artist.albums.exists?(:year => 2010)

Métodos de has_many (y IV)

collection.build(attributes = {})

a = artist.albums.build(:title => "Believe")a.new_record? # truea.save!

collection.create(attributes = {})

a = artist.albums.create(:title => "Asylum")a.new_record? # false

¿Cuándo se guardan los objetos?has_many

Los objetos asociados se guardan al asignarlosExcepto:

I Si falla la validación de cualquiera de ellos, la asignación secancela

I Si el extremo que tiene en has_many es nuevo, se esperará (hastaque se guarde)

4 Herencia

Especificación

class Musician < ActiveRecord::Basehas_and_belongs_to_many :bands

class Band < ActiveRecord::Basehas_and_belongs_to_many :musicians

Tablas

bandsidname string

has_and_belongs_to_many

musiciansidname string

has_and_belongs_to_many

bands_musiciansband_id integermusician_id integer

La tabla intermedia

El nombre se forma contatenando los plurales de los nombres delas clasesSe ordenan alfabéticamenteHay que indicar que no precisa clave primaria

create_table :companies_offices, :id => false do |t|t.references :companyt.references :office

Parecidos con has_many

Simplificando, la API es la misma que en el caso de has_many

Las reglas para guardar los objetos en la base de datos tambiénson las mismasAsí que vamos a aplicar el principio DRY ;)

4 Herencia

Usando la API de consultas

artist = Artist.find_by_name(’B.B. King’)artist.albums.where("year < 2000")

Simplificando, se traduce en:

SELECT * FROM "artists" LEFT OUTER JOIN "albums"ON "albums"."artist_id" = "artists"."id"WHERE (albums.year < 2000)

Eager-loadingn + 1 consultas

albums = Album.limit(10)albums.each do |album|puts "#{album.artist.name}: #{album.title}"

Esto dispararía 1 consulta para recuperar los álbums. . .. . . y otra por cada album para recuperar su artista¡En total, 101 consultas!

Eager-loadingDe n + 1 a tan sólo 2

albums = Album.includes(:artist).limit(10)

Esto dispara sólo 2 consultas:I Una para los álbumsI Y otra para todos los artistas relacionados

SELECT albums.* FROM albums LIMIT 10SELECT artists.* FROM artists WHEREWHERE (albums.artist_id IN (1, 2, 5))

4 Herencia

Dependencias entre objetos

A veces la existencia de un objeto depende de otroSi por ejemplo borramos un artista, nos interesa borrar sus discos

class Artisthas_many :albums, :dependent => :destroy

u2 = Artist.find_by_name(’U2’)u2.destroy # Elimina a U2 y todos sus álbums

Tipos de dependencia

destroy Llama a destroy para cada uno de los objetosasociados

delete/delete_all Borra los objetos asociados pero sin llamar adestroy

nullify Pone la clave ajena a nullrestrict No permite borrar el objeto si hay otro asociado

Se usan principalmente con has_many y has_oneDebe evitarse su uso en belongs_to por la posibilidad de dejarobjetos "huérfanos"

4 Herencia

No siempre es posible

Seguir las convenciones permite escribir menos código. . .pero no siempre es posibleAfortunadamente, ActiveRecord ofrece un buen número demodificadores

Ignorando las convenciones

class Log < ActiveRecord::Basehas_many :log_entries

class LogEntry < ActiveRecord::Basebelongs_to :log

log.log_entries # No parece muy bonito

class Log < ActiveRecord::Basehas_many :entries, :class_name => "LogEntry"

class LogEntry < ActiveRecord::Basebelongs_to :log

log.entries # Mejor :)

class Log < ActiveRecord::Basehas_many :entries, :class_name => "LogEntry",:foreign_key => "l_id"

class LogEntry < ActiveRecord::Basebelongs_to :log, :foreign_key => "l_id"

4 Herencia

Ordenación

Permite ordenar los objetos dentro de la relación

class Artist < ActiveRecord::Basehas_many :albums, :order => :year

queen = Artist.find_by_name("Queen")queen.albums.map(&:year) # [ 1973, 1974, 1974, ... ]

Sentido de la ordenación

class Artist < ActiveRecord::Basehas_many :albums, :order => "year desc"

queen = Artist.find_by_name("Queen")queen.albums.map(&:year) # [ 1995, 1991, 1989, ... ]

Ordenación compuesta

class Artist < ActiveRecord::Basehas_many :albums, :order => "year asc, title desc"

queen = Artist.find_by_name("Queen")queen.albums.map(&:title)# [ "Queen", "Sheer heart attack", "Queen II", ... ]

Condiciones

Permite filtrar la relación con condiciones

class Artist < ActiveRecord::Basehas_many :albumshas_many :greatest_albums, :class_name => "Album",

:conditions => { :rate => [ 4, 5 ] }end

queen = Artist.find_by_name("Queen")queen.greatest_albums.first

Límites

Limita la cantidad de objetos devueltos

class Artist < ActiveRecord::Basehas_many :albums, :order => :yearhas_many :latest_albums, :class_name => "Album",

:limit => 2, :order => "year desc"end

queen = Artist.find_by_name("Queen")queen.latest_albums.map(&:year) # [ 1995, 1991 ]

EjercicioAñadiendo árbitros a Bet on Rails

1 Queremos que los usuarios de Bet on Rails sepan quién pita cadapartido

2 Añadir a Bet on Rails un modelo Referee que represente a losárbitros

3 Interesan su nombre y su fecha de nacimiento4 Implementar una gestión básica usando el "scaffold"5 Hacer que para cada partido se pueda seleccionar un árbitro

(pista: collection_select)6 ¿Cómo podría acceder a los partidos ya pitados por un árbitro?

4 Herencia

Algo con dirección

class Address < ActiveRecord::Basebelongs_to :addressable, :polymorphic => true

class Company < ActiveRecord::Basehas_many :addresses, :as => :addressable

class Person < ActiveRecord::Basehas_one :address, :as => :addressable

¿Dónde está el truco?

Además de la columna _id, se usa una columna _type

En esa columna se guarda la clase del objeto asociado

address = Address.find_by_postal_code("35017")address.addressable_id # 1address.addressable_type # "Company"

En la migración hay que indicar que se trata de una relaciónpolimórfica

t.references :addressable, :polymorphic => true

4 Herencia

¿Para qué?

Nos permite asociar dos modelos a través de un terceroUsos típicos:

1 Para añadir "lógica" a una asociación HABTM2 Como "atajo" en asociaciones has_many anidadas

Se verá más claro con dos ejemplos

Join models

Supongamos una asociación HABTM a la que queremos añadirlógica (atributos, validaciones, etc.)

class User < ActiveRecord::Basehas_and_belongs_to_many :groups

class Group < ActiveRecord::Basehas_and_belongs_to_many :users

Join models

Puede sustituirse por un modelo intermedio con dos relacionesuno a muchos

class User < ActiveRecord::Basehas_many :subscriptions

class Group < ActiveRecord::Basehas_many :subscriptions

class Subscription < ActiveRecord::Basebelongs_to :userbelongs_to :group

Join models

create_table :subscriptions do |t|t.references :usert.references :groupt.boolean :activet.timestamps

Join models

Así se puede llegar de un extremo al otro:

class User < ActiveRecord::Basehas_many :subscriptionshas_many :groups, :through => :subscriptions

class Group < ActiveRecord::Basehas_many :subscriptionshas_many :users, :through => :subscriptions

class Subscription < ActiveRecord::Basebelongs_to :userbelongs_to :group

Como si fuera HABTM

Se pueden usar los métodos habituales entre los extremosSe crearán "automáticamente" nuevos objetos intermediossiempre que sea necesarioCuando se eliminen, no se llamará a "destroy"

lanzarote = User.find_by_name("Lanzarote")lanzarote.groups.empty? # truelanzarote.subscriptions.empty? # trueknights = Group.find_by_name("Knights")lanzarote.groups << knightslanzarote.subscriptions.empty? # false

has_many anidados

class Document < ActiveRecord::Basehas_many :pages

class Page < ActiveRecord::Basebelongs_to :documenthas_many :paragraphs

class Paragraph < ActiveRecord::Basebelongs_to :page

has_many anidados

class Document < ActiveRecord::Basehas_many :pageshas_many :paragraphs, :through => :pages

class Page < ActiveRecord::Basebelongs_to :documenthas_many :paragraphs

class Paragraph < ActiveRecord::Basebelongs_to :page

4 Herencia

Single Table Inheritance (STI)Todos los campos —de la clase base y las derivadas— en unatablaEl tipo concreto se almacena en la columna “type”Se puede pasar la opción --parent al generador

-path: string-size: integer

-lines: string-words: integer

Binary

-format: string

filespath stringsize stringlines integerwords integerformat stringtype string

Ejercicio 1Modelando una plataforma de e-learning

Queremos escribir una plataforma de e-learningEn una primera versión, tenemos cursos, temas y tareas

I Cada curso tiene una serie de temas y tareas asociadasI Además, los temas y las tareas tienen asociados una serie de

documentos

Nuestros usuarios serán profesores y estudiantesUn curso puede tener varios profesores asignadosUn estudiante puede matricularse en cualquier curso

I Nos interesa saber cuándo formalizó la matrículaI Y también nos gustaría poder desactivarla en un momento dado

Implementarlo a nivel de modelos, olvidando la interfaz web

Ejercicio 2Modelando los equipos para Bet on Rails

1 Añadir a Bet on Rails un modelo Team que representa a losequipos e implementar una gestión básica (con el "scaffold")

2 La clase Game dejará de usar cadenas para representar a losequipos y usará esa nueva clase

3 Al crear/editar mediante el navegador deben seleccionarse losequipos de los registrados en la base de datos (pista:collection_select)

4 ¿Cómo podría acceder a los partidos que un equipo ha jugado encasa?

Relaciones en Rails 3(1 1,1 n,n n)

Documents

Transcript of Relaciones en Rails 3(1 1,1 n,n n)

Revolucion Rails

Restful Rails Es

Rails Plugins. Javier Ramirez

Buenas Prácticas de desarrollo en Ruby on Rails

Internacionalización rails 4

Savera guide rails

Cómo programar para Ruby on Rails

Desarrollo de Apps para iOSsantiago/docencia/ios/2014-16/... · 2015-12-09 · $ gem install rails --version=4.0.1 Ejecutar: $ rails new gametop3 $ cd gametop3 $ rails generate scaffold

Rails top features

Desarrollo Ágil y Ruby on Rails

Introducción a rails 3 · Introducción a rails 3!! Rails es un framework de desarrollo de aplicaciones web escrito en el lenguaje Ruby. Está diseñado para hacer la programación

Plugins de autenticación en Rails - Lightning talk Las Palmas On Rails 09/02/2010

1,1 Clase Introductoria

Interface de Voz con Rails

¿Rails no escala?

Introducción a Ruby on Rails

Presentación Rails Girls Santiago, Chile (diciembre de 2015)

105.desarrollo rest-con-rails

Ruby on Rails en NetBeans 6.1

Desarrollo Ágil con Ruby on Rails