Pouvez-vous me parler d'une gemme ruby ​​décent que je peux utiliser pour des jointures complexes?

Question

Cochon soutenant un autre question I posted, j'ai un complexe find() qui change si un certain ID est nul ou non. Voir ici:

if self.id.nil? 
    blocks = AppointmentBlock.find(:first, 
    :conditions => ['appointment_blocks.employee_id = ? and ' + 
        '(time_slots.start_at between ? and ? or time_slots.end_at between ? and ?)', 
    self.employee_id, self.time_slot.start_at, self.time_slot.end_at, 
    self.time_slot.start_at, self.time_slot.end_at], 
    :joins => 'join time_slots on time_slots.time_slot_role_id = appointment_blocks.id') 
else 
    blocks = AppointmentBlock.find(:first, 
    :conditions => ['appointment_blocks.id != ? and ' + 
        'appointment_blocks.employee_id = ? and ' + 
        '(time_slots.start_at between ? and ? or time_slots.end_at between ? and ?)', 
    self.id, self.employee_id, self.time_slot.start_at, self.time_slot.end_at, 
    self.time_slot.start_at, self.time_slot.end_at], 
    :joins => 'join time_slots on time_slots.time_slot_role_id = appointment_blocks.id') 
end 

Je me demande s'il y a un petit bijou là-bas qui me permet de passer en: premier: conditions de choses type que un bloc de code. J'ai vu ez_where sur github mais je ne savais pas si elle avait été abandonnée ou non puisqu'elle n'avait pas d'activité dernièrement (bien que cela puisse signifier qu'elle soit très solide sans aucun bogue) Des idées?

Answer 1

Vous pouvez également jeter un oeil à Arel qui:

Arel est une algèbre relationnelle pour Ruby. Il 1) simplifie la génération complexe de requêtes SQL

L'approche est intégrée dans Rails 3 aussi bien. Fournit un support vraiment élégant pour construire des chaînes complexes d'étendues et de requêtes.

Answer 2

Lorsque j'ai une requête SQL compliquée impliquant beaucoup de jointures, UNION, etc, je crée une vue dans mysql. Ensuite, je crée un modèle ActiveRecord et suis capable de lire directement les résultats via ActiveRecord. Un autre avantage de cette technique est que le SQL compliqué et son plan d'exécution ne seront calculés qu'une seule fois par le dbms (lorsque vous créez la vue) plutôt qu'à chaque exécution.

Selon la situation, j'utilise rake ou une migration pour créer/recréer les vues.

Notez que vous souhaiterez généralement recréer les vues si l'un des schémas des tables sous-jacentes est modifié.

Ajouté:

Exemple

class SessionViews2 < ActiveRecord::Migration 
    def self.up 
    execute "DROP View if exists room_usages" # Dropping both view and table 
    execute "DROP Table if exists room_usages" # has helped in some corner cases 
    execute "CREATE VIEW room_usages AS 
SELECT 
    CONCAT(rooms.id,schedules.id) as id 
    , rooms.id    as room_id    
    , rooms.conference_id as conference_id 
    , rooms.popular_room as room_popular_room 
    , schedules.id     as schedule_id 
    , schedules.timetable_id   as schedule_timetable_id     
    , schedules.display_start_time as schedule_display_start_time  
    , schedules.display_end_time  as schedule_display_end_time  
    , sess.id    as session_id   
    , sess.title    as title    
    , sess.subtitle   as subtitle   
    FROM 
    rooms 
    INNER JOIN schedule_rooms ON rooms.id = schedule_rooms.room_id 
    INNER JOIN schedules ON schedule_rooms.schedule_id = schedules.id 
    INNER JOIN sessions as sess ON schedules.session_id = sess.id 
    WHERE 
    schedule_rooms.cancelled_time IS NULL 
    AND schedules.cancelled_time IS NULL" 
    end 

    def self.down 
    execute "DROP View if exists room_usages" 
    execute "DROP Table if exists room_usages" 
    end 
end 

Modèle room_usage.rb

class RoomUsage < ActiveRecord::Base 

    ############################################################ 
    #               # 
    #  This is a VIEW! No DB table, Read-Only   # 
    #               # 
    ############################################################ 

    belongs_to :conference 
    belongs_to :timetable, :foreign_key => :schedule_timetable_id 
    belongs_to :session 

end