Quelle est votre expérience dans le développement sur Google App Engine?

Question

est GQL facile à apprendre pour quelqu'un qui connaît SQL? Comment est Django / Python? Est-ce que App Engine fait vraiment mise à l'échelle facile? Y at-il une protection intégrée contre les « GQL Injections »? Et ainsi de suite ...

J'aimerais entendre les hauts et les bas pas si évident de l'utilisation du moteur d'application.

Vive!

Answer 1

Le problème le plus flagrant et frustrant est le api datastore, qui ressemble beaucoup et est très bien pensé et facile à travailler si vous êtes habitué à SQL, mais a une limite de 1000 ligne dans tous les resultsets de requête, et vous pouvez » t nombre d'accès ou des compensations au-delà. J'ai rencontré des problèmes les plus étranges, d'être en mesure pas vraiment d'ajouter ou d'accès aux données pour un modèle une fois qu'il va au-delà de 1000 lignes.

Voir la Stack Overflow discussion au sujet de la limite de 1000 ligne

a écrit un très bon résumé de cela et d'autres problèmes

Cela dit, le moteur d'application est un outil vraiment génial d'avoir à la disposition de ceux, et je vraiment plaisir à travailler avec elle. Il est parfait pour le déploiement de micro services Web (par exemple: de JSON api). Utiliser dans d'autres applications

Answer 2

Mon expérience avec le moteur Google app a été grande, et 1000 limite de résultat a été supprimé , voici un lien vers les notes de version:

notes de version app-moteur

  

Plus de 1000 limite de résultat - C'est   droite: avec addition de Curseurs et   le point culminant de nombreux petits   la stabilité et la performance datastore   des améliorations au cours des derniers mois,   nous sommes maintenant assez confiant pour enlever   la limite maximum de résultat tout à fait.   Que vous faites un Fetch,   itérer, ou à l'aide d'un curseur, il y a   aucune limite sur le nombre de résultats.

Answer 3

GQL est extrêmement simple - c'est un sous-ensemble de l'instruction SQL « SELECT », rien de plus. Il est seulement une couche de confort sur le dessus des API de niveau inférieur, cependant, et toutes les analyses sont faites en Python.

Au lieu de cela, je recommande d'utiliser l'API de requête, qui est d'ordre procédural, ne nécessite pas l'analyse de l'exécution, et rend les vulnérabilités « injection GQL » totalement impossible (même si elles sont impossibles à GQL correctement écrit de toute façon). L'API de requête est très simple: Appel .Toutes () sur une classe de modèle, ou appelez db.Query (modelname). L'objet de la requête a .filter (field_and_operator, valeur), .order (field_and_direction) et .ancestor (entité) méthodes, en plus de tous les équipements gql objets ont (.get (), .fetch (), .count ()) , etc.) Chacune des méthodes de requête renvoie l'objet de la requête elle-même pour la commodité, vous pouvez les enchaîner:

  

= MyModel.all résultats () filtrer ( "foo =", 5) .order ( "- bar").. Récupération (10)

est équivalent à:

  

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

Answer 4

Un inconvénient majeur lorsque l'on travaille avec AppEngine était la limite de requête 1k, qui a été mentionné dans les commentaires déjà. Ce que je ne l'ai pas vu mentionné mais est le fait qu'il ya un ordre triables intégré, avec lequel vous pouvez contourner ce problème. Depuis le livre de cuisine 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()

Le code ci-dessus avec l'API à distance (voir cet article ) permet vous de récupérer autant d'entités que vous avez besoin.

Vous pouvez utiliser le code ci-dessus comme ceci:

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

myModels = deepFetch(allMyModel)

Answer 5

Dans un premier temps j'ai eu la même expérience que d'autres qui le processus de transition de SQL à GQL - un peu bizarre de ne pas pouvoir faire les JOIN sont, compter plus de 1000 lignes, etc. Maintenant que je l'ai travaillé avec elle pour quelques mois j'aime absolument le moteur d'application. Je portage tous mes anciens projets sur elle.

Je l'utilise pour héberger plusieurs applications Web à fort trafic (aux heures de pointe un d'entre eux obtient 50k frappe une minute.)

Answer 6

Google App Engine n'utilise pas une base de données réelle, et utilise apparemment une sorte de carte de hachage distribuée. Cela se prête à des comportements différents que les gens qui sont habitués à SQL ne sont tout simplement pas aller voir au début. Ainsi, par exemple obtenir un nombre d'éléments dans SQL régulière devrait être une opération rapide, mais avec GQL il est tout simplement pas aller travailler de la même manière.

Voici quelques questions:

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

Dans mon expérience personnelle, il est un ajustement, mais la courbe d'apprentissage est très bien.