Usando el estilo de los rieles 3, ¿cómo escribiría lo contrario de:
Foo.includes(:bar).where(:bars=>{:id=>nil})Quiero encontrar dónde la identificación NO es nula. Lo intenté:
Foo.includes(:bar).where(:bars=>{:id=>!nil}).to_sqlPero eso vuelve:
=> "SELECT \"foos\".* FROM \"foos\" WHERE (\"bars\".\"id\" = 1)"Eso definitivamente no es lo que necesito, y casi parece un error en ARel.
Respuestas:
La forma canónica de hacer esto con Rails 3:
Foo.includes(:bar).where("bars.id IS NOT NULL")ActiveRecord 4.0 y superior agrega where.notpara que pueda hacer esto:
Foo.includes(:bar).where.not('bars.id' => nil)
Foo.includes(:bar).where.not(bars: { id: nil })Cuando trabajo con ámbitos entre tablas, prefiero aprovechar mergepara poder usar los ámbitos existentes con mayor facilidad.
Foo.includes(:bar).merge(Bar.where.not(id: nil))Además, dado includesque no siempre elige una estrategia de unión, también debe usarla referencesaquí, de lo contrario puede terminar con SQL no válido.
Foo.includes(:bar)
.references(:bar)
.merge(Bar.where.not(id: nil))rails undefined method 'not_eq' for :confirmed_at:Symbol..
wherecondiciones de encadenamiento de @BKSpurgeon son simplemente construir un AST, no golpea la base de datos hasta que golpeas un método terminal como eacho to_a. Crear la consulta no es una preocupación de rendimiento; lo que está solicitando de la base de datos es.
No es un error en ARel, es un error en su lógica.
Lo que quieres aquí es:
Foo.includes(:bar).where(Bar.arel_table[:id].not_eq(nil))true, que es un booleano. :id => truete mete id = 1en SQLese.
field_name != 'NULL'.
id = 't':)
Para Rails4:
Entonces, lo que quieres es una combinación interna, por lo que realmente deberías usar el predicado de combinaciones:
Foo.joins(:bar)
Select * from Foo Inner Join Bars ...Pero, para el registro, si desea una condición "NOT NULL" simplemente use el predicado not:
Foo.includes(:bar).where.not(bars: {id: nil})
Select * from Foo Left Outer Join Bars on .. WHERE bars.id IS NOT NULLTenga en cuenta que esta sintaxis informa una desuso (habla de un fragmento de cadena SQL, pero supongo que la condición de hash se cambia a cadena en el analizador), así que asegúrese de agregar las referencias al final:
Foo.includes(:bar).where.not(bars: {id: nil}).references(:bar)ADVERTENCIA DE DEPRECACIÓN: Parece que está ansioso por cargar tablas (una de: ....) a las que se hace referencia en un fragmento de cadena de SQL. Por ejemplo:
Post.includes(:comments).where("comments.title = 'foo'")Actualmente, Active Record reconoce la tabla en la cadena y sabe UNIR la tabla de comentarios a la consulta, en lugar de cargar comentarios en una consulta separada. Sin embargo, hacer esto sin escribir un analizador SQL completo es inherentemente defectuoso. Como no queremos escribir un analizador SQL, estamos eliminando esta funcionalidad. A partir de ahora, debe indicar explícitamente a Active Record cuando hace referencia a una tabla desde una cadena:
Post.includes(:comments).where("comments.title = 'foo'").references(:comments)
referencesllamada me ayudó!
No estoy seguro de que esto sea útil, pero esto es lo que funcionó para mí en Rails 4
Foo.where.not(bar: nil)Con Rails 4 es fácil:
Foo.includes(:bar).where.not(bars: {id: nil})Ver también: http://guides.rubyonrails.org/active_record_querying.html#not-conditions
!nilse evalúa comotrueen Ruby, y Arel se traducetruea1una consulta SQL. Entonces, la consulta generada es, de hecho, lo que solicitó, esto no fue un error de ARel.