ActiveRecord: query non utilizza corretta condizione tipo per STI sottoclasse

Question

Ho una serie di sottoclassi STI che ereditano da una classe User base. Sto scoprendo che in determinate condizioni all'interno di una definizione sottoclasse, le query sui sottoclassi non utilizzano correttamente la condizione type.

class User < ActiveRecord::Base 
    # ... 
end 

class Admin < User 
    Rails.logger.info "#{name}: #{all.to_sql}" 
    # ... 
end 

Quando si carica la console Rails in fase di sviluppo, si fa quello che ci si aspetterebbe:

Admin: SELECT `users`.* FROM `users` WHERE `users`.`type` IN ('Admin') 

Ma quando colpisce l'app (localhost/Pow), manca la condizione type e ottengo questo :

Admin: SELECT `users`.* FROM `users` 

Ma non attraverso l'app quando quando distribuito a un server di gestione temporanea:

Admin: SELECT `users`.* FROM `users` WHERE `users`.`type` IN ('Admin') 

Questo, naturalmente, fa sì che qualsiasi query eseguite qui in app dev (ma non dalla console) per non essere corretto. Nello specifico, sto provando a precaricare una (piccola) cache di valori db esistenti per creare alcuni metodi utili basati su quei dati. Senza lo scope del tipo, la cache è ovviamente errata!

Dalla stessa posizione (Admin), otteniamo la seguente contraddizione confusione:

[11] pry(Admin)> Admin.finder_needs_type_condition? 
=> true 
[12] pry(Admin)> Admin.send(:type_condition).to_sql 
=> "`users`.`type` IN ('Admin')" 
[13] pry(Admin)> Admin.all.to_sql 
=> "SELECT `users`.* FROM `users`" 

Inoltre, ho definito una sottoclasse usa e getta Q < User all'interno del file user.rb. Mi sono collegato Q.all.to_sql dalla sua definizione, dalla definizione di Admin, e da una vista. In questo modo, si ottiene:

From Q: Q: SELECT `users`.* FROM `users` WHERE `users`.`type` IN ('Q') 
From Admin: Q: SELECT `users`.* FROM `users` 
From View: Q: SELECT `users`.* FROM `users` WHERE `users`.`type` IN ('Q') 

Che cosa potrebbe causare, nella prima riga della definizione Admin sottoclasse in admin.rb, qualsiasi sottoclasse di User non riuscire a utilizzare il suo type_condition?

questo sta causando prove di sviluppo di fallire, e così è di una certa importanza per la mia app. Cosa diavolo potrebbe causare questa differenza di comportamento? Qualcuno può pensare a un modo più generale intorno al problema di non avere le condizioni STI definite su una sottoclasse durante la sua definizione solo nell'ambiente di sviluppo app?

Answer 1

Una differenza tra produzione e sviluppo è la seguente riga all'interno della configurazione dell'applicazione:

# config/environments/development.rb 
config.eager_load = false 

vs.

# config/environments/production.rb 
config.eager_load = true 

Così sul vostro ambiente di produzione, tutti i clases vengono caricati quando l'applicazione è iniziato. Quando eager_load è impostato su falso, Rails proverà a caricare automaticamente la classe User quando si carica per la prima volta la classe Admin.

Dato che, presumo che tu abbia un'altra classe o modulo chiamato User.

FYI: ActiveRecord ha un metodo chiamato finder_needs_type_condition?.Dovrebbe restituire vero per una classe che utilizza STI:

User.finder_needs_type_condition? # should be false 
Admin.finder_needs_type_condition? # should be true 

Answer 2

Attualmente, qualsiasi User avranno un :type colonna vuota. Potrebbe essere un problema?

Hai provato a fare User una super classe? Per esempio.

class User < ActiveRecord::Base 
end 

class Admin < User; end 
class NormalUser < User; end