Was ist der Unterschied zwischen der Verwendung? und% beim Desinfizieren von Feldern in ActiveRecord?

Question

Ich bin seit einiger Zeit verwirrt über den Unterschied zwischen der Verwendung eines Fragezeichens, z.

Foo.find(:all, :conditions => ['bar IN (?)', @dangerous]) 

und unter Verwendung von Sprintf-Stil-Feldtypen, z.

Bar.find(:all, :conditions => ['qux IN (%s)', @dangerous]) 

in Desinfektionseingängen. Gibt es irgendeinen Sicherheitsvorteil, wenn Sie wissen, dass Sie nach einer Zahl suchen - wie einer ID - und nicht nach einer Zeichenkette,% d über verwenden? Oder fragen Sie einfach nach einem Big Nasty Error, wenn stattdessen eine Zeichenkette erscheint ?

Ändert sich das überhaupt mit der neueren .where-Syntax in Rails 3 und 4?

Answer 1

%s ist für Strings vorgesehen. Der Hauptunterschied besteht darin, dass %s keine Anführungszeichen hinzufügt. Von ActiveRecord::QueryMethods.where:

Lastly, you can use sprintf-style % escapes in the template. This works slightly differently than the previous methods; you are responsible for ensuring that the values in the template are properly quoted. The values are passed to the connector for quoting, but the caller is responsible for ensuring they are enclosed in quotes in the resulting SQL. After quoting, the values are inserted using the same escapes as the Ruby core method Kernel::sprintf .

Beispiele:

User.where(["name = ? and email = ?", "Joe", "joe@example.com"]) 
# SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com'; 

User.where(["name = '%s' and email = '%s'", "Joe", "joe@example.com"]) 
# SELECT * FROM users WHERE name = 'Joe' AND email = 'joe@example.com'; 

Update:

Sie sind ein Array übergeben. %s scheint Anrufe .to_s auf das Argument, so könnte dies nicht funktioniert wie erwartet:

User.where("name IN (%s)", ["foo", "bar"]) 
# SELECT * FROM users WHERE (name IN ([\"foo\", \"bar\"])) 

User.where("name IN (?)", ["foo", "bar"]) 
# SELECT * FROM users WHERE (name IN ('foo','bar')) 

Für einfache Abfragen Sie die Hash-Notation verwenden:

User.where(name: ["foo", "bar"]) 
# SELECT * FROM users WHERE name IN ('foo', 'bar') 

Answer 2

Soweit ich, %s einfach Einsätze sagen kann, in Ihre Anfrage was auch immer @dangerous.to_s passiert, und Sie sind dafür verantwortlich.

Zum Beispiel, wenn @dangerous ist ein Array von ganzen Zahlen, dann werden Sie eine SQL-Fehlermeldung erhalten:

@dangerous = [1,2,3] 
User.where("id IN (%s)", @dangerous) 

in der folgenden falschen Syntax führen wird:

SELECT `users`.* FROM `users` WHERE (id IN ([1, 2, 3])) 

während:

User.where("id IN (?)", @dangerous) 

erzeugt die richtige Abfrage:

SELECT `users`.* FROM `users` WHERE (id IN (1,2,3)) 

So ist scheint mir, dass, wenn Sie sehr einfach, sehr gut, was Sie tun, sollten Sie die ? Bediener seine Arbeit tun lassen, vor allem, wenn Sie den Inhalt @dangerous als sicher nicht vertrauen.