Query repeated property starts with - google-app-engine

Question

Say I have a movie database where you can search by title.
I have a Movie model that looks like the following (simplified)
class Movie(ndb.Model):
name = ndb.StringProperty(required=True)
queryName = ndb.ComputedProperty(lambda self: [w.lower() for w in self.name.split()], repeated=True)
#staticmethod
def parent_key():
return ndb.Key(Movie, 'parent')
The queryName is just a lower case list of the words in Movie.name. The parent_key() is just for the query basically
If I was searching for the movie Forest Gump, I would want it to show up for the following search terms (and more, these are just examples)
'fo' - 'forest' starts with 'fo'
'gu' - 'gump' starts with 'gu'
'gu fo' - 'forest' starts with 'fo' and 'gump' starts with 'gu'
I can get the first two easily with a query similar to the following
movies = Movie\
.query(ancestor=Movie.parent_key())\
.filter(Movie.queryName >= x)\
.filter(Movie.queryName < x + u'\ufffd')\
.feth(10)
where x is 'fo' or 'gu'. Again, this is simply a query that works not my actual code. That comes later. If I expand a bit on the above query to look for two words I thought I could do something like the following however, it doesn't work.
movies = Movie\
.query(ancestor=Movie.parent_key())\
.filter(Movie.queryName >= 'fo')\
.filter(Movie.queryName < 'fo' + u'\ufffd')\
.filter(Movie.queryName >= 'gu')\
.filter(Movie.queryName < 'gu' + u'\ufffd')\
.feth(10)
Now , this doesn't work because it is looking in queryName to see if it has any item which starts with 'fo' and starts with 'gu'. Since that could never be true for a single item in the list, the query returns nothing.
The question is how do you query for Movies which have a queryName with an item that starts with 'fo' AND an item that starts with 'gu'?
Actual Code:
class MovieSearchHandler(BaseHandler):
def get(self):
q = self.request.get('q')
if q:
q = q.replace('&', '&').lower()
filters = self.create_filter(*q.split())
if filters:
movies = Movie\
.query(ancestor=Movie.parent_key())\
.filter(*filters)\
.fetch(10)
return self.write_json([{'id': m.movieId, 'name': m.name} for m in movies])
return self.write_json([])
def create_filter(self, *args):
filters = []
if args:
for prefix in args:
filters.append(Movie.queryName >= prefix)
filters.append(Movie.queryName < prefix + u'\ufffd')
return filters
Update:
My current solution is
class MovieSearchHandler(BaseHandler):
def get(self):
q = self.request.get('q')
if q:
q = q.replace('&', '&').lower().split()
movieFilter, reducable = self.create_filter(*q)
if movieFilter:
movies = Movie\
.query(ancestor=Movie.parent_key())\
.filter(movieFilter)\
.fetch(None if reducable else 10)
if reducable:
movies = self.reduce(movies, q)
return self.write_json([{'id': m.movieId, 'name': m.name} for m in movies])
return self.write_json([])
def create_filter(self, *args):
if args:
if len(args) == 1:
prefix = args[0]
return ndb.AND(Movie.queryName >= prefix, Movie.queryName < prefix + u'\ufffd'), False
ands = [ndb.AND(Movie.queryName >= prefix, Movie.queryName < prefix + u'\ufffd')
for prefix in args]
return ndb.OR(*ands), True
return None, False
def reduce(self, movies, terms):
reducedMovies = []
for m in movies:
if len(reducedMovies) >= 10:
return reducedMovies
if all(any(n.startswith(t) for n in m.queryName) for t in terms):
reducedMovies.append(m)
return reducedMovies
Still looking for something better though
Thanks