Qual è la tua esperienza nello sviluppo su Google App Engine?

Question

È GQL facile da imparare per chi conosce SQL? Come è Django / Python? Ha App Engine davvero fare ridimensionamento facile? C'è qualche protezione integrata contro le "iniezioni" GQL? E così via ...

Mi piacerebbe sentire il gruppo di continuità non-così-evidenti e bassi di utilizzo di App Engine.

Cheers!

Answer 1

Il problema più evidente e frustrante è l'API datastore, che sembra grande ed è molto ben pensato e facile da lavorare, se siete abituati a SQL, ma ha un limite di 1000 fila in tutti i gruppi di risultati di query, e si puo' conta di accesso T o compensazioni oltre. Ho incontrato problemi più strano, con realtà non essere in grado di aggiungere o l'accesso ai dati per un modello una volta che va al di là di 1000 righe.

Vedere la Stack Overflow discussione sul limite di 1000 righe

ha scritto una buona sintesi di questo e di altri problemi

Detto questo, App Engine è davvero un ottimo strumento per avere a disposizione quelle, e mi piace molto lavorare con esso. È perfetto per la distribuzione di servizi web micro (ad esempio: JSON API). Da utilizzare in altre applicazioni

Answer 2

La mia esperienza con App Engine di Google è stata grande, e la 1000 Limite risultato è stato rimossi , ecco un link per le note di rilascio:

rilascio

app-motore di note

  

Non è più limite di 1000 risultato - che è   a destra: con l'aggiunta di cursori e   il culmine di molti piccoli   la stabilità e le prestazioni Datastore   miglioramenti nel corso degli ultimi mesi,   ora siamo abbastanza sicuri da rimuovere   il massimo risultato limite del tutto.   Sia che si sta facendo un'operazione di recupero,   iterazione, o utilizzando un cursore, non c'è   limiti al numero di risultati.

Answer 3

GQL è estremamente semplice - è un sottoinsieme della SQL 'SELECT' affermazione, niente di più. E 'solo uno strato di convenienza sopra la parte superiore delle API di livello inferiore, però, e tutte le analisi è fatto in Python.

Invece, mi consiglia di utilizzare l'API di query, che è procedurale, non richiede l'analisi di run-time, e fa le vulnerabilità 'GQL iniezione' del tutto impossibile (anche se sono impossibili in GQL scritto correttamente comunque). L'API di query è molto semplice: Call .all () sul modello di una classe, o chiamare db.Query (ModelName). L'oggetto Query ha .filter (field_and_operator, valore), .order (field_and_direction) e .ancestor (entità) metodi, oltre a tutti i servizi GQL oggetti hanno (.get (), .fetch (), .count ()) , ecc) Ciascuno dei metodi query restituisce l'oggetto query stessa per comodità, in modo da poterli catena:

  

Risultati = MyModel.all () filtrare ( "foo =", 5) .order ( "- bar").. Fetch (10)

è equivalente a:

  

risultati = MyModel.gql ( "WHERE foo = 5 ORDER BY bar DESC LIMIT 10"). Fetch ()

Answer 4

Un grave inconveniente quando si lavora con AppEngine era il limite di query 1k, che è stato menzionato nei commenti già. Quello che non ho visto citato, però, è il fatto che v'è un built-in ordine ordinabili, con cui è possibile ovviare a questo problema. Dal libro di cucina AppEngine:

def deepFetch(queryGen,key=None,batchSize = 100):
  """Iterator that yields an entity in batches.

  Args:
    queryGen: should return a Query object
    key: used to .filter() for __key__
    batchSize: how many entities to retrieve in one datastore call

  Retrieved from http://tinyurl.com/d887ll (AppEngine cookbook).
  """

  from google.appengine.ext import db

   # AppEngine will not fetch more than 1000 results
  batchSize = min(batchSize,1000)

  query = None
  done = False
  count = 0

  if key:
    key = db.Key(key)

  while not done:
    print count
    query = queryGen()
    if key:
      query.filter("__key__ > ",key)
    results = query.fetch(batchSize)
    for result in results:
      count += 1
      yield result
    if batchSize > len(results):
      done = True
    else:
      key = results[-1].key()

Il codice sopra insieme con Remote API (vedi questo articolo ) permette di recuperare il maggior numero di entità di cui hai bisogno.

È possibile utilizzare il codice di cui sopra in questo modo:

def allMyModel():
  q = MyModel.all()

myModels = deepFetch(allMyModel)

Answer 5

In un primo momento ho avuto la stessa esperienza come gli altri che la transizione da SQL a GQL - un po 'strano di non essere in grado di fare join, contare più di 1000 righe, ecc Ora che ho lavorato con lui per pochi mesi io adoro il motore app. Sto porting tutti i miei vecchi progetti su di esso.

Io lo uso per ospitare diverse applicazioni web ad alto traffico (nelle ore di punta uno di loro si 50k colpisce un minuto.)

Answer 6

Google App Engine non usa un database vero e proprio, e apparentemente utilizza una sorta di mappa di hash distribuita. Ciò si presta ad alcuni comportamenti diversi che le persone che sono abituati a SQL solo non stanno andando a vedere in un primo momento. Così, per esempio ottenere un conteggio di elementi in SQL regolare dovrebbe essere un'operazione veloce, ma con GQL è solo non andare a lavorare nello stesso modo.

Qui ci sono alcuni più problemi:

http://blog.burnayev.com/2008/04/gql -limitations.html

Nella mia esperienza personale, è un adeguamento, ma la curva di apprendimento è bene.