Groß- und Kleinschreibung where-Klausel in gql Abfrage für String

Question

die Google App Engine-Datenspeicher verwenden, gibt es eine Möglichkeit, eine gql Abfrage auszuführen, die eine WHERE-Klausel auf einem Stringdatentyp angibt, die Groß- und Kleinschreibung ist? Ich bin nicht immer sicher, was Fall wird der Wert in sein wird. Die docs angeben, dass die in der Groß- und Kleinschreibung für meine Werte, ist es eine Möglichkeit, diese unempfindlich zu machen?

zum Beispiel des DB-Modell wäre dies:

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

und die Daten wie folgt aussehen:

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

ich möchte sagen,

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

und haben returnvalue enthalten

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

Answer 1

Ich glaube nicht, es ist ein Operator wie die im Datenspeicher.

Sie die Eingabe der Kategoriedaten steuern Sie? Wenn ja, sollten Sie eine kanonische Form wählen, um es zu speichern in (Klein- oder Großbuchstaben). Wenn Sie den ursprünglichen Fall aus irgendeinem Grunde speichern müssen, dann könnte man nur zwei Spalten speichern - eine mit dem Original, eine mit der standardisierten ein. So können Sie eine normale tun können WHERE-Klausel.

Answer 2

Der Datenspeicher nicht Groß- und Kleinschreibung Vergleiche unterstützen, weil Sie nicht Index-Abfragen können, die sie verwenden (eine Indexsperre, die Werte transformiert). Die Lösung ist eine normalisierte Version der Zeichenfolge zusätzlich zu dem Standard zu speichern, wie Peter vermuten läßt. Die Festigkeitsklassen in der AETycoon Bibliothek kann hilfreich sein, insbesondere DerivedProperty.

Answer 3

Dieser Thread war hilfreich und macht mich mit ähnlichem Ansatz beitragen will Teilsuchspiel möglich zu machen. Ich füge ein weiteres Feld auf Datenspeicher Art und jedes Wort als einen Satz auf normalisierte Satz speichern und dann in Filter verwenden, um zu kollidieren. Dies ist ein Beispiel mit einem Clojure. Normalisieren Teil sollte einfach zu Java übersetzt mindestens (Dank an #clojure @raek), während Datenbank-Interaktion zu jeder Sprache konvertierbar sein sollte:

(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])]))))))