def remove_kind(kind):
results = []
query, curr_results, cursor = fetch_keys(kind)
results.extend(curr_results)
while curr_results:
query, curr_results, cursor = fetch_keys(kind,
query=query,
cursor=cursor)
results.extend(curr_results)
if not results:
return
delete_outside_transaction = False
with datastore.Transaction():
# Now that we have all results, we seek to delete.
print('Deleting keys:')
print(results)
ancestors = get_ancestors(results)
if len(ancestors) > TRANSACTION_MAX_GROUPS:
delete_outside_transaction = True
else:
datastore.delete([result.key for result in results])
if delete_outside_transaction:
datastore.delete([result.key for result in results])
def add_characters():
with datastore.Transaction() as xact:
for key_path, character in zip(KEY_PATHS, CHARACTERS):
if key_path[-1] != character['name']:
raise ValueError(
('Character and key don\'t agree', key_path, character))
entity = datastore.Entity(key=datastore.Key(*key_path))
entity.update(character)
xact.put(entity)
print('Adding Character %s %s' %
(character['name'], character['family']))
def test_transaction(self):
entity = datastore.Entity(key=datastore.Key('Company', 'Google'))
entity['url'] = u'www.google.com'
with datastore.Transaction() as xact:
results = datastore.get([entity.key])
if len(results) == 0:
xact.put(entity)
self.case_entities_to_delete.append(entity)
# This will always return after the transaction.
retrieved_entity, = datastore.get([entity.key])
self.case_entities_to_delete.append(retrieved_entity)
self.assertEqual(retrieved_entity, entity)
def test_save_key_self_reference(self):
key = datastore.Key('Person', 'name')
entity = datastore.Entity(key=key)
entity['fullName'] = u'Full name'
entity['linkedTo'] = key # Self reference.
with datastore.Transaction():
datastore.put([entity])
self.case_entities_to_delete.append(entity)
query = datastore.Query(kind='Person')
query.add_filter('linkedTo', '=', key)
stored_persons = list(query.fetch(limit=2))
self.assertEqual(len(stored_persons), 1)
stored_person = stored_persons[0]
self.assertEqual(stored_person['fullName'], entity['fullName'])
self.assertEqual(stored_person.key.path, key.path)
self.assertEqual(stored_person.key.namespace, key.namespace)
def test_save_multiple(self):
with datastore.Transaction() as xact:
entity1 = self._get_post()
xact.put(entity1)
# Register entity to be deleted.
self.case_entities_to_delete.append(entity1)
second_post_content = {
'title': u'How to make the perfect homemade pasta',
'tags': [u'pasta', u'homemade'],
'publishedAt': datetime.datetime(2001, 1, 1),
'author': u'Silvano',
'isDraft': False,
'wordCount': 450,
'rating': 4.5,
}
entity2 = self._get_post(post_content=second_post_content)
xact.put(entity2)
# Register entity to be deleted.
self.case_entities_to_delete.append(entity2)
keys = [entity1.key, entity2.key]
matches = datastore.get(keys)
self.assertEqual(len(matches), 2)
def _generic_test_post(self, name=None, key_id=None):
entity = self._get_post(id_or_name=(name or key_id))
with datastore.Transaction():
datastore.put([entity])
# Register entity to be deleted.
self.case_entities_to_delete.append(entity)
if name is not None:
self.assertEqual(entity.key.name, name)
if key_id is not None:
self.assertEqual(entity.key.id, key_id)
retrieved_entity, = datastore.get([entity.key])
# Check the keys are the same.
self.assertEqual(retrieved_entity.key.path, entity.key.path)
self.assertEqual(retrieved_entity.key.namespace, entity.key.namespace)
self.assertTrue(
_compare_dataset_ids(retrieved_entity.key.dataset_id,
entity.key.dataset_id))
# Check the data is the same.
retrieved_dict = dict(retrieved_entity.items())
entity_dict = dict(entity.items())
self.assertEqual(retrieved_dict, entity_dict)
# Now let's check for Thing entities named 'Computer'
query.add_filter('name', '=', 'Computer')
print(list(query.fetch()))
# If you want to filter by multiple attributes,
# you can call .add_filter multiple times on the query.
query.add_filter('age', '=', 10)
print(list(query.fetch()))
# Now delete them.
datastore.delete(sample_keys)
# You can also work inside a transaction.
# (Check the official docs for explanations of what's happening here.)
with datastore.Transaction() as xact:
print('Creating and saving an entity...')
key = datastore.Key('Thing', 'foo')
thing = datastore.Entity(key)
thing['age'] = 10
xact.put(thing)
print('Creating and saving another entity...')
key2 = datastore.Key('Thing', 'bar')
thing2 = datastore.Entity(key2)
thing2['age'] = 15
xact.put(thing2)
print('Committing the transaction...')
# Now that the transaction is commited, let's delete the entities.
def tearDown(self):
with datastore.Transaction():
keys = [entity.key for entity in self.case_entities_to_delete]
datastore.delete(keys)