Entre mayúsculas y minúsculas cláusula where de la consulta gql para StringProperty

Question

Uso del almacén de datos appengine Google, hay una manera de llevar a cabo una consulta gql que especifica una cláusula WHERE en un tipo de datos StringProperty que es sensible a mayúsculas? No siempre estoy seguro de qué caso el valor estará en. Los documentos especifican que el caso en que es sensible para mis valores, ¿hay una manera de hacer esto insensible?

por ejemplo, el modelo DB sería la siguiente:

from google.appengine.ext import db
class Product(db.Model):
    id = db.IntegerProperty()
    category = db.StringProperty()

y los datos se ve así:

id         category
===================
1          cat1
2          cat2
3          Cat1
4          CAT1
5          CAT3
6          Cat4
7          CaT1
8          CAT5

Me gustaría decir

gqlstring = "WHERE category = '{0}'".format('cat1')
returnvalue = Product.gql(gqlstring)

y tienen returnvalue contener

id         category
===================
1          cat1
3          Cat1
4          CAT1
7          CaT1

Answer 1

No creo que hay un operador de esa manera en el almacén de datos.

Cómo se controla la entrada de los datos de categoría? Si es así, usted debe elegir una forma canónica para almacenarlo en (todo en minúsculas o en mayúsculas). Si necesita almacenar el caso original, por alguna razón, entonces sólo podría almacenar dos columnas - uno con el original, uno con el estandarizado. De esa manera usted puede hacer una normal de la cláusula WHERE.

Answer 2

El almacén de datos no admite comparaciones insensibles caso, porque no se puede índice consultas que los utilizan (a excepción de un índice que transforma los valores). La solución es almacenar una versión normalizada de la cadena, además de la norma uno, como sugiere Peter. Las clases de propiedad en la biblioteca AETycoon pueden resultar útiles, en particular, DerivedProperty.

Answer 3

Este hilo ha sido útil y hace que quiera contribuir con enfoque similar para hacer búsqueda de coincidencia parcial posible. Agrego un campo más en el tipo de almacén de datos y guardar cada palabra en la frase normalizada como un conjunto y luego su uso en el filtro de chocar. Este es un ejemplo con una Clojure. Normalizar la parte fácil debería traducirse a Java al menos (gracias a @raek en #clojure), mientras que la interacción de base de datos debe ser convertible a cualquier idioma:

(use '[clojure.contrib.string :only [split lower-case]])
(use '[appengine-magic.services.datastore :as ds])

; initialize datastore kind entity
(ds/defentity AnswerTextfield [value, nvalue, avalue]) 

; normalize and lowercase a string
(defn normalize [string-to-normalize]
  (lower-case
    (apply str
      (remove #(= (Character/getType %) Character/NON_SPACING_MARK)
               (java.text.Normalizer/normalize string-to-normalize java.text.Normalizer$Form/NFKD)))))

; save original value, normalized value and splitted normalized value
(defn textfield-save! [value]
  (ds/save! 
    (let [nvalue (normalize value)]
      (ds/new* AnswerTextfield [value nvalue (split #" " nvalue)]))))

; normalized search
(defn search-normalized [value]
  (ds/query :kind AnswerTextfield
            :filter [(= :nvalue (normalize value))]))

; partial normalized word search
(defn search-partial [value]
  (flatten
    (let [coll []]
      (for [splitted-value (split #" " (normalize value))]
        (merge coll 
          (ds/query :kind AnswerTextfield
                    :filter [(in :avalue [splitted-value])]))))))