Using always async ndb operations in ndb gae

Question

I'm developing with gae and ndb and I find that I have to write a lot of code for ndb gets and queries. Sometimes I need two versions (sometimes 3 or more).

Suppose I have the following Models and functions inside them:

class MainEnt(ndb.Model):
    """Main entity. The parent is the user_key"""
    name = ndb.StringProperty()
    child = ndb.KeyProperty()

    def get_created_by(self, user_id):
        """Get the MainEnt's created by user_id"""
        # stuff... getting the query and returning the results

    def get_created_by_async(self, user_id):
        """Get async the MainEnt's created by user_id"""
        # stuff... getting the query async and returning a future

    @ndb.tasklet
    def get_childs_async_tasklet(self, mainent_key):
        """Get async the childs of a MainEnt"""
        # stuff... yielding the query async. and raise ndb.Return()...

    @ndb.tasklet
    def get_created_by_async_tasklet(self, user_id):
        """Get async the MainEnt's created by user_id"""
        # stuff... yielding the query async. and raise ndb.Return()...

    @ndb.tasklet
    def get_created_by_async_tasklet_with_childs(self, user_id):
        """Get async the MainEnt's created by user_id and its childs"""
        # stuff... yielding the query async. calling get_childs.. and raise ndb.Return()...

    @ndb.tasklet
    def get_voted_by_async_tasklet(self, user_id):
        """Get async the MainEnt's voted by user_id"""
        # stuff... yielding the query async raise ndb.Return()...

    @ndb.tasklet
    def get_voted_by_async_tasklet_with_childs(self, user_id):
        """Get async the MainEnt's voted by user_id and it's childs"""
        # stuff... yielding the query async, calling get_childs.. and raise ndb.Return()...

    @ndb.tasklet
    def get_created_and_voted_by_async_tasklet(self, user_id):
        """yield get_created_by_async_tasklet and get_voted_by_async_tasklet in parallel"""
        # stuff... yielding the other two functions and return results...

class ChildEnt(ndb.Model):
    name = ndb.StringProperty()

As you see MainEnt have three methods that return the "same" (sometime more) results but are used in different contexts.

1) The sync function only used when I need to get the results and getting that results are the only "ndb operation".

2) The async function only used when I need to get the results but I also perform some other ndb query that I want to overlap.

3) The tasklet async function only used when I need to get the results, get the Child Entities of this results and maybe also performing some other ndb operation.

Because I find writing too many functions...It's correct to only write an async tasklet function that is going to be called in each of the previous situations??

I mean even if I just need the results synchronous I will call the get_created_by_async_tasklet and then call get_results on the future returned by the function.

Is there any inconvenience on performance, error prone, etc... into doing this? I find out much more simple to always use an ndb async tasklet for every query, get, etc... and only call its results if I need too or otherwise perform more async operations and later call get_results.

Hope this is well explained...

Thanks in advance!

Answer 1

There is nothing wrong with only using async calls, then using get_result immediately if you want the results syncronously. This is exactly what the ndb synchronous functions do:

Here is an example from ndb.Key:

def get(self, **ctx_options):
    """Synchronously get the entity for this Key.

    Return None if there is no such entity.
    """
    return self.get_async(**ctx_options).get_result()