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)