App Engine datastore non supporta operatore OR

StackOverflow https://stackoverflow.com/questions/930966

Domanda

Sto cercando di interrogare l'archivio dati di Google per qualcosa di simile (con pm -> persistanceManager): 

String filters = "(  field == 'value' ||  field == 'anotherValue' )";
Query query = pm.newQuery(myType.class, filters);

Quando eseguo - io sono sempre di nuovo:. App Engine datastore non supporta operatore OR

Qual è l'approccio migliore nella gente esperienza per questo tipo di query?

Qualsiasi aiuto apprezzato!

È stato utile?

Soluzione

Eseguire più query. Il datastore, come tutti gli altri database, non è in grado di eseguire in modo efficiente disgiunzioni. A differenza di altri database, espone questa difficoltà per l'utente, per mettere in chiaro che quello che stai facendo non è efficiente. La tua unica soluzione è quella di eseguire più query - uno per ciascuno o -. E combinarle

Altri suggerimenti

Non so se le implementazioni JDO e JPA di Gae supportano questa, ma utilizzando l'API di basso livello, è possibile utilizzare l'operatore in per questo, in una query. 

Query query = new Query("Issue");
List<String> list = Arrays.asList("NEW", "OPEN", "ACCEPTED");
query.addFilter("status", FilterOperator.IN, list);

DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
PreparedQuery preparedQuery = datastore.prepare(query);
for (Entity entity : preparedQuery.asIterable()) {
    // should iterate over 'NEW', 'OPEN' and 'ACCEPTED' issues
}

Google App Engine - Query e Indici :

  

Filtri di query

     

Un Filtro specifica un nome di campo,   un operatore e un valore. Il valore   devono essere forniti dal app; non può   fare riferimento a un'altra proprietà, o di essere   calcolato in termini di altri   proprietà. L'operatore può essere qualsiasi   il seguente: < <= == >= >

     
    

Nota: L'interfaccia datastore Java non supporta l'= e     IN filtro     operatori che vengono implementati nel     Interfaccia datastore Python. (Nel     un'interfaccia Python, questi operatori sono     implementato nel lato client     biblioteche come datastore multipla     interrogazioni; non sono caratteristiche del     datastore stesso.)

  
     

Il soggetto di un filtro può essere qualsiasi   campo oggetto, compreso il primario   chiave e il genitore gruppo entità (vedi    transazioni ).

     

Un'entità deve corrispondere tutti i filtri di essere   un risultato. Nella sintassi di stringa JDOQL,   più filtri vengono specificati   separati da && (logico "e").   Altre combinazioni logiche di filtri   (Logico "o", "not") non sono   supportato.

     

A causa del modo in cui l'App Engine   datastore esegue query, un singolo   query non può utilizzare filtri disuguaglianza   (< <= >= >) su più di un   proprietà. filtri disuguaglianza multiple   sulla stessa proprietà (come interrogazione   per una serie di valori) sono consentiti.   Vedere Restrizioni Query .

In sostanza si sta andando ad avere sia per ristrutturare i dati in modo che si può trovare quello che stai cercando con una condizione o multipla "e" condizioni o si sta andando ad avere per recuperare i dati tramite due (o più) query e filtro / si combinano nel codice.

Scusate il ritardo al gioco .. Ho appena eseguito attraverso la vostra domanda oggi.

Un altro modo per "simulare" 'IN' e 'OR' comportamento è di utilizzare il "basso livello" archivio dati API. Il DatastoreService supporta un metodo get (), che accetta un insieme di chiavi e restituisce una mappa di tutte le entità che corrispondono il passato in Keys. Si tratta di un'interfaccia, ma c'è una comoda DatastoreServiceFactory disponibile che erogare un esempio pronto per l'uso.

Purtroppo, Google ha deciso che non vogliono promuovere questo approccio API di basso livello e preferiscono che gli sviluppatori utilizzano JDO o JPA, quindi non c'è alcuna documentazione a disposizione oltre alle JavaDocs e qualunque codice di campioni che si potrebbe trovare quando Google "DatastoreService".

TL

Ultime novità .. almeno io sono solo ottenerlo. Mentre stavo scaricando l'ultimo SDK Java per GAE ho notato sulla note di rilascio che "Numero 29: Esporre lotto ottiene" è stato fissato nella versione più recente (v1.2.1). In pratica sembra che abbiamo (io sto cercando lo stesso supporto a quanto pare) può avere un'alternativa basata JDO piuttosto che dover discesa al "basso livello" archivio dati API. Ho appena scaricato l'ultima Java SDK GAE così non ho avuto l'opportunità di testare ancora nulla, ma ho voluto dare un heads-up al più presto. Io postare qualcosa di più che imparare dopo che ho avuto la possibilità di confermare questo "fix".

La prego di accettare le mie scuse se ho rotto StackOverflow galateo da ri-postare il mio commento come risposta, ma ho deciso di farlo per due ragioni. In primo luogo perché, anche se sono io rivolgendosi di nuovo lo stesso problema, secondo me queste nuove informazioni sembra fornire una "risposta" del tutto diverso al problema. E in secondo luogo, ero preoccupato che la forma di commenti non potrebbe ottenere la vostra attenzione, prima che ci si speso una grande quantità di tempo esaminando la prima risposta che ho fornito.

La prossima volta ci penserò più attentamente prima di agire.

TL

Un modo per semplificare dover "fai da te" potrebbe essere quella di utilizzare query con parametri: 

   Query query = pm.newQuery(mytype.class);
   query.setFilter("field == autoParam");
   query.declareParameters("String autoParam");

   List<String> params = myListOfThingsFieldCanBeEqualTo;

   Set merged = new HashSet();
   for (String f : params) {
     merged.addAll(q.execute(f));
   }

A differenza di risposta Cletus', O-ing lavori , nella versione più recente di App Engine in ogni caso.

In effetti, ho trovato non O-ing di lavoro in App Engine 1.3.0 che ho avuto, ma secondo Google App Engine - query e indici (lo stesso Cletus fonte di cui alla sua risposta),

  

Un'entità deve corrispondere tutti i filtri per essere un risultato. Nella sintassi della stringa JDOQL, è possibile separare più filtri con || (Logico "o") e && (logico "e"), anche se tenere a mente che || possono essere usati soltanto quando i filtri che separa hanno tutti lo stesso nome di campo. In altre parole, || è legale solo in situazioni in cui i filtri che separa possono essere combinati in un singolo contiene () filtri.

Ho pensato che dopo la sua risposta (e dall'ultima volta che ho aggiornato il mio App Engine), App Engine deve essere stato aggiornato in materia.

Aggiornamento App Engine a 1.3.4, e le opere OR-ing! Pur con la limitazione.

Grazie a Cletus comunque:)

È possibile utilizzare il metodo contiene 

String filters = "( :values.contains(field) )";
Query query = pm.newQuery(myType.class, filters);
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top