Quante letture di Datastore consumano ogni operazione di recupero, conteggio e query?

Question

Sto leggendo su Google App Engine raggruppa molti utenti (Fig1, Fig2, Fig3) che non riescono a capire da dove proviene l'elevato numero di dati Datastore nei loro rapporti di fatturazione.
Come forse sapete, lo Datastore reads ha un limite di 50.000 ore/giorno, oltre questo budget è necessario pagare.

Le operazioni 50 K sembrano molte risorse, ma sfortunatamente sembra che ogni operazione (Query, Entity fetch, Count ..), nasconda diverse letture di Datastore.

È possibile conoscere tramite API o qualche altro approccio, quante letture di Datastore sono nascoste dietro le comuni chiamate RPC.get, RPC.runquery?

Appstats sembra inutile in questo caso perché fornisce solo i dettagli RPC e non il costo nascosto delle letture.

Avere un semplice modello come questo:

class Example(db.Model): 
    foo = db.StringProperty()  
    bars= db.ListProperty(str) 

e entità del datastore, mi interessa il costo di questo tipo di operazioni:

items_count = Example.all(keys_only = True).filter('bars=','spam').count() 

items_count = Example.all().count(10000) 

items = Example.all().fetch(10000) 

items = Example.all().filter('bars=','spam').filter('bars=','fu').fetch(10000) 

items = Example.all().fetch(10000, offset=500) 

items = Example.all().filter('foo>=', filtr).filter('foo<', filtr+ u'\ufffd') 

Answer 1

Vedi http://code.google.com/appengine/docs/billing.html#Billable_Resource_Unit_Cost. Una query costa 1 lettura più 1 lettura per ogni entità restituita. "Restituito" include le entità ignorate da offset o conteggio. Quindi è 1001 letture per ciascuno di essi:

Example.all(keys_only = True).filter('bars=','spam').count() 
Example.all().count(1000) 
Example.all().fetch(1000) 
Example.all().fetch(1000, offset=500) 

Per questi, il numero di letture a carico è 1 più il numero di soggetti che corrispondono ai filtri:

Example.all().filter('bars=','spam').filter('bars=','fu').fetch() 
Example.all().filter('foo>=', filtr).filter('foo<', filtr+ u'\ufffd').fetch() 

Invece di usare conteggio voi considerare la possibilità di memorizzare il conteggio nel datastore, se necessario è necessario aggiornare il conteggio più di una volta al secondo. http://code.google.com/appengine/articles/sharding_counters.html

Se possibile, è necessario utilizzare i cursori anziché uno scostamento.

Answer 2

Giusto per essere sicuro:

Sono quasi sicuro:

Example.all().count(10000) 

Questo si usa operazioni datastore piccoli (non c'è bisogno di prendere le entità, solo chiavi), quindi questo conterebbe come 1 leggi + 10.000 (max) piccole operazioni.