Problema durante il recupero di record con array vuoto

Question

Ho una tabella di circa 100 utenti e ho anche una matrice di ID utente. Quello che volevo fare è mostrare tutti gli utenti che non fanno parte di questo array di ID utente. Quando faccio qualcosa del genere

User.where('id NOT IN (?)', [9, 2, 3, 4]) 

Restituisce correttamente i record in cui l'id dell'utente non appartiene a tale array. Tuttavia, se tale matrice è vuota in questo modo

User.where('id NOT IN (?)', []) 

Esso non restituisce alcun utente indietro e la query SQL assomiglia a questo

SELECT "users".* FROM "users" WHERE (id NOT IN (NULL)) 

Qualcuno sa perché questo accade o questo potrebbe essere un bug? Sto usando Rails 3.2.5 con PostgreSQL.

Answer 1

ActiveRecord (almeno 3.2.1) tratta gli array vuoti come NULL. I segnaposto in una chiamata where vengono gestiti da sanitize_sql. Se si traccia attraverso il codice per un po ', si arriva a replace_bind_variables:

def replace_bind_variables(statement, values) #:nodoc: 
    raise_if_bind_arity_mismatch(statement, statement.count('?'), values.size) 
    bound = values.dup 
    c = connection 
    statement.gsub('?') { quote_bound_value(bound.shift, c) } 
end 

e poi quote_bound_value:

def quote_bound_value(value, c = connection) #:nodoc: 
    if value.respond_to?(:map) && !value.acts_like?(:string) 
    if value.respond_to?(:empty?) && value.empty? 
     c.quote(nil) 
    else 
     value.map { |v| c.quote(v) }.join(',') 
    end 
    else 
    c.quote(value) 
    end 
end 

un array vuoto in grado di soddisfare tutte le quattro condizioni per arrivare a c.quote(nil) e questo è da dove proviene il tuo NULL. Tutta la logica speciale che conduce a c.quote(nil) indica che si tratta di un comportamento intenzionale.

dicendo in (o NOT IN) con una lista vuota:

where c in() 

dovrebbe produrre un errore di SQL così forse la gente AR stanno cercando di impedire che, tranquillamente girando così male SQL in c in (null). Si noti che nessuno di questi:

select ... from t where c in (null); 
select ... from t where c not in (null); 

dovrebbe mai produrre alcun risultato a causa del comportamento di NULL di SQL. Questo è un classico errore newbie e le persone AR dovrebbero davvero saperlo meglio.

Preferirei anch'io un'eccezione: dirmi che sto per lanciare un proiettile per i piedi sarebbe molto più amichevole di una semplice pistola.

---

Sintesi:

1. Questa "array vuoto significa NULL" comportamento è intenzionale.
2. Non dovresti mai provare mai where('c in (?)', []) o where('c not in (?)', []) poiché nessuna delle due affermazioni ha molto senso.
3. Aggiorna il tuo codice Ruby per verificare gli array vuoti e fai tutto il necessario per ottenere i risultati che ti aspetti.

Answer 2

In Rails 4 è possibile utilizzare User.where.not(id: []) che fornirà il risultato corretto.Produce:

SELECT "users".* FROM "users" WHERE (1 = 1) 

Purtroppo User.where('id NOT IN (?)', []) dovrebbe essere equivalente, ma non lo è. Ti dà ancora il risultato sbagliato:

SELECT "users".* FROM "users" WHERE (id NOT IN (NULL)) 

Riferimenti:

• https://github.com/rails/rails/issues/778
• https://github.com/rails/arel/commit/cbff1bcf
• https://github.com/rails/rails/pull/8332
• https://github.com/rails/rails/commit/8d02afeaee8993bd0fde69687fdd9bf30921e805

Answer 3

User.where('id NOT IN (?)', ids+[0]) 

record attivo involucro

Answer 4

Uso di ruby:

User.where.not(id: []) 

Questo gestisce la questione array vuoto per voi.

Answer 5

Non so se questo è il problema richiesto, ma sono venuto qui per trovare tutti i record con un attributo di array vuoto (serializzato). Ho risolto per Rails 5.0 in questo modo:

User.where(my_array_attribute: nil) 

O per l'inverso:

User.where.not(my_array_attribute: nil)