CODEWITHSUNDEEP
pythongoogle-app-enginegoogle-cloud-datastoreapp-engine-ndb
gsinha
gsinha

Reputation: 1185

How to fetch the latest data in GAE Python NDB

I am using GAE Python. I have two root entities: 

class X(ndb.Model):  
    subject = ndb.StringProperty()  
    grade = ndb.StringProperty()  

class Y(ndb.Model):  
    identifier = ndb.StringProperty()  
    name = ndb.StringProperty()  
    school = ndb.StringProperty()  
    year = ndb.StringProperty()  
    result = ndb.StructuredProperty(X, repeated=True)

Since google stores our data across several data centers, we might not get the most recent data when we do a query as shown below(in case some changes have been "put"): 

def post(self):  
    identifier = self.request.get('identifier')  
    name = self.request.get('name')  
    school = self.request.get('school')  
    year = self.request.get('year')  
    qry = Y.query(ndb.AND(Y.name==name, Y.school==school, Y.year==year))  
    record_list = qry.fetch()

My question: How should I modify the above fetch operation to always get the latest data

I have gone through the related google help doc but could not understand how to apply that here

Based on hints from Isaac answer, Would the following be the solution(would "latest_record_data" contain the latest data of the entity): 

def post(self):  
    identifier = self.request.get('identifier')  
    name = self.request.get('name')  
    school = self.request.get('school')  
    year = self.request.get('year')  
    qry = Y.query(ndb.AND(Y.name==name, Y.school==school, Y.year==year))  
    record_list = qry.fetch()  
    record = record_list[0]  
    latest_record_data = record.key.get()

Upvotes: 2

Views: 3008

Answers (1)

Isaac
Isaac

Reputation: 788

There's a couple ways on app engine to get strong consistency, most commonly using gets instead of queries and using ancestor queries.

To use a get in your example, you could encode the name into the entity key:

class Y(ndb.Model):
  result = ndb.StructuredProperty(X, repeated=True)

def put(name, result):
  Y(key=ndb.Key(Y, name), result).put()

def get_records(name):
  record_list = ndb.Key(Y, name).get()
  return record_list

An ancestor query uses similar concepts to do something more powerful. For example, fetching the latest record with a specific name:

import time

class Y(ndb.Model):
  result = ndb.StructuredProperty(X, repeated=True)

  @classmethod
  def put_result(cls, name, result):
    # Don't use integers for last field in key. (one weird trick)
    key = ndb.Key('name', name, cls, str(int(time.time())))
    cls(key=key, result=result).put()

  @classmethod
  def get_latest_result(cls, name):
    qry = cls.query(ancestor=ndb.Key('name', name)).order(-cls.key)
    latest = qry.fetch(1)
    if latest:
      return latest[0]

The "ancestor" is the first pair of the entity's key. As long as you can put a key with at least the first pair into the query, you'll get strong consistency.

Upvotes: 3

Related Questions