def testMultiQueryIterator(self):
q = query.Query(kind='Foo').filter(Foo.tags.IN(['joe', 'jill']))
q = q.order(Foo.name)
@tasklets.synctasklet
def foo():
it = iter(q)
res = []
while (yield it.has_next_async()):
val = it.next()
res.append(val)
self.assertEqual(res, [self.jill, self.joe])
foo()
def testFetchAsync(self):
q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name)
@tasklets.synctasklet
def foo():
res = yield q.fetch_async(10)
self.assertEqual(res, [self.jill, self.joe])
res = yield q.fetch_async(2)
self.assertEqual(res, [self.jill, self.joe])
res = yield q.fetch_async(1)
self.assertEqual(res, [self.jill])
foo()
def testIterAsync(self):
q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name)
@tasklets.synctasklet
def foo():
it = iter(q)
res = []
while (yield it.has_next_async()):
val = it.next()
res.append(val)
self.assertEqual(res, [self.jill, self.joe])
foo()
def testFullDistributiveLaw(self):
q = query.Query(kind='Foo').filter(Foo.tags.IN(['jill', 'hello']))
q = q.filter(Foo.rate.IN([1, 2]))
DisjunctionNode = query.DisjunctionNode
ConjunctionNode = query.ConjunctionNode
FilterNode = query.FilterNode
expected = DisjunctionNode(
[ConjunctionNode([FilterNode('tags', '=', 'jill'),
FilterNode('rate', '=', 1)]),
ConjunctionNode([FilterNode('tags', '=', 'jill'),
FilterNode('rate', '=', 2)]),
ConjunctionNode([FilterNode('tags', '=', 'hello'),
FilterNode('rate', '=', 1)]),
ConjunctionNode([FilterNode('tags', '=', 'hello'),
FilterNode('rate', '=', 2)])])
self.assertEqual(q.filters, expected)
def testMapAsync(self):
q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name)
callback = lambda e: e.name
@tasklets.tasklet
def callback_async(e):
yield tasklets.sleep(0.01)
raise tasklets.Return(e.name)
@tasklets.synctasklet
def foo():
fut = q.map_async(callback)
res = yield fut
self.assertEqual(res, ['jill', 'joe'])
fut = q.map_async(callback_async)
res = yield fut
self.assertEqual(res, ['jill', 'joe'])
foo()
def testCursorsKeysOnly(self):
q = query.Query(kind='Foo')
it = q.iter(produce_cursors=True, keys_only=True)
expected = [self.joe.key, self.jill.key, self.moe.key]
self.assertRaises(datastore_errors.BadArgumentError, it.cursor_before)
self.assertRaises(datastore_errors.BadArgumentError, it.cursor_after)
before = []
after = []
for i, ent in enumerate(it):
self.assertEqual(ent, expected[i])
before.append(it.cursor_before())
after.append(it.cursor_after())
before.append(it.cursor_before())
after.append(it.cursor_after())
self.assertEqual(before[1], after[0])
self.assertEqual(before[2], after[1])
self.assertEqual(before[3], after[2])
self.assertEqual(before[3], after[3]) # !!!
def foo():
key1 = model.Key(flat=('Foo', 1))
key2 = model.Key(flat=('Foo', 2))
ent1 = model.Expando(key=key1, foo=42, bar='hello')
ent2 = model.Expando(key=key2, foo=1, bar='world')
key1a, key2a = yield self.ctx.put(ent1), self.ctx.put(ent2)
self.assertTrue(key1 in self.ctx._cache) # Whitebox.
self.assertTrue(key2 in self.ctx._cache) # Whitebox.
self.assertEqual(key1, key1a)
self.assertEqual(key2, key2a)
@tasklets.tasklet
def callback(ent):
return ent
qry = query.Query(kind='Foo')
results = yield self.ctx.map_query(qry, callback)
self.assertEqual(results, [ent1, ent2])
self.assertTrue(results[0] is ent1)
self.assertTrue(results[1] is ent2)
def testCursorsEfficientPaging(self):
# We want to read a 'page' of data, get the cursor just past the
# page, and know whether there is another page, all with a single
# RPC. To do this, set limit=pagesize+1, batch_size=pagesize.
q = query.Query(kind='Foo')
cursors = {}
mores = {}
for pagesize in [1, 2, 3, 4]:
it = q.iter(produce_cursors=True, limit=pagesize+1, batch_size=pagesize)
todo = pagesize
for ent in it:
todo -= 1
if todo <= 0:
break
cursors[pagesize] = it.cursor_after()
mores[pagesize] = it.probably_has_next()
self.assertEqual(mores, {1: True, 2: True, 3: False, 4: False})
self.assertEqual(cursors[3], cursors[4])
def testFetchPage(self):
# This test implicitly also tests fetch_page_async().
q = query.Query(kind='Foo')
page_size = 1
res, curs, more = q.fetch_page(page_size)
self.assertEqual(res, [self.joe])
self.assertTrue(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [self.jill])
self.assertTrue(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [self.moe])
self.assertFalse(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [])
self.assertFalse(more)
page_size = 2
res, curs, more = q.fetch_page(page_size)
self.assertEqual(res, [self.joe, self.jill])
self.assertTrue(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [self.moe])
self.assertFalse(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [])
self.assertFalse(more)
page_size = 3
res, curs, more = q.fetch_page(page_size)
self.assertEqual(res, [self.joe, self.jill, self.moe])
self.assertFalse(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [])
self.assertFalse(more)
page_size = 4
res, curs, more = q.fetch_page(page_size)
self.assertEqual(res, [self.joe, self.jill, self.moe])
self.assertFalse(more)
res, curs, more = q.fetch_page(page_size, start_cursor=curs)
self.assertEqual(res, [])
self.assertFalse(more)
def testCursors(self):
qo = query.QueryOptions(produce_cursors=True)
q = query.Query(kind='Foo')
it = q.iter(options=qo)
expected = [self.joe, self.jill, self.moe]
self.assertRaises(datastore_errors.BadArgumentError, it.cursor_before)
self.assertRaises(datastore_errors.BadArgumentError, it.cursor_after)
before = []
after = []
for i, ent in enumerate(it):
self.assertEqual(ent, expected[i])
before.append(it.cursor_before())
after.append(it.cursor_after())
before.append(it.cursor_before())
after.append(it.cursor_after())
self.assertEqual(before[1], after[0])
self.assertEqual(before[2], after[1])
self.assertEqual(before[3], after[2])
self.assertEqual(before[3], after[3]) # !!!
def testCountEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.count(1), 0)
def testCount(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.count(10), 2) self.assertEqual(q.count(1), 1)
def testGetKeysOnly(self): qo = query.QueryOptions(keys_only=True) q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.get(options=qo), self.jill.key)
def testGetEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.get(), None)
def foo():
yield self.create_entities()
qry = query.Query(kind='Foo')
res = yield self.ctx.map_query(qry, None)
raise tasklets.Return(res)
def testOrderedQuery(self): q = query.Query(kind='Foo') q = q.order(Foo.rate).order().order(-Foo.name) res = list(q) self.assertEqual(res, [self.moe, self.joe, self.jill])
def testNotEqualOperator(self): q = query.Query(kind='Foo').filter(Foo.rate != 2) res = list(q) self.assertEqual(res, [self.joe, self.moe])
def testInOperator(self):
q = query.Query(kind='Foo').filter(Foo.tags.IN(('jill', 'hello')))
res = list(q)
self.assertEqual(res, [self.joe, self.jill])
def testFetch(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.fetch(10), [self.jill, self.joe]) self.assertEqual(q.fetch(1), [self.jill])
def testBasicQuery(self): q = query.Query(kind='Foo') q = q.filter(Foo.name >= 'joe').filter(Foo.name <= 'moe').filter() res = list(q) self.assertEqual(res, [self.joe, self.moe])
def testFetchEmpty(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jillian') self.assertEqual(q.fetch(1), [])
def testFetchKeysOnly(self): qo = query.QueryOptions(keys_only=True) q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.fetch(10, options=qo), [self.jill.key, self.joe.key])
def testGet(self): q = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) self.assertEqual(q.get(), self.jill)
def foo():
yield self.create_entities()
qry = query.Query(kind='Foo')
res = yield self.ctx.map_query(qry, callback, options=qo)
raise tasklets.Return(res)
def testMultiQuery(self): q1 = query.Query(kind='Foo').filter(Foo.tags == 'jill').order(Foo.name) q2 = query.Query(kind='Foo').filter(Foo.tags == 'joe').order(Foo.name) qq = query._MultiQuery([q1, q2]) res = list(qq) self.assertEqual(res, [self.jill, self.joe])
