def GetEntities(project_id, json_lines, outer_parent_key=None, namespace=None): """Create gcloud entities from json string entries. project_id: String gcloud project id that entities are for. json_lines: File or other line-by-line iterator of json strings to turn into entities. outer_parent_key: Optional datastore.Key instance to act as the parent_key of all top level entities. namespace: Optional string namespace for entities. """ entity_keys = {} for line in json_lines: item = json.loads(line) kind, idx = item.pop('id') parent = item.pop('parent', None) if (kind, idx) in entity_keys: raise DuplicateKeyError( 'Duplicate entities with id (%s, %s)' % (kind, idx)) if parent: parent_key = entity_keys[tuple(parent)] else: parent_key = outer_parent_key key = datastore.Key( kind, idx, project=project_id, parent=parent_key, namespace=namespace) e = datastore.Entity(key=key) e.update(item) entity_keys[(kind, idx)] = key entity_keys[idx] = key yield e
def test_save_key_self_reference(self): parent_key = datastore.Key('Residence', 'NewYork') key = datastore.Key('Person', 'name', parent=parent_key) entity = datastore.Entity(key=key) entity['fullName'] = u'Full name' entity['linkedTo'] = key # Self reference. datastore.put([entity]) self.case_entities_to_delete.append(entity) query = datastore.Query(kind='Person') # Adding ancestor to ensure consistency. query.ancestor = parent_key query.add_filter('linkedTo', '=', key) stored_persons = list(query.fetch(limit=2)) self.assertEqual(stored_persons, [entity])
def post(self): entity = datastore.Entity(key=datastore.Key(ENTITY_KIND, project=PROJECT)) data = json.loads(self.request.body) data['status'] = REQUEST_RECEIVED entity['data'] = json.dumps(data) ds.put(entity) publish_msg(str(entity.key.id)) self.response.write(format_entity(entity))
def test_query___key___filter(self): rickard_key = datastore.Key(*populate_datastore.RICKARD) query = self._base_query() query.add_filter('__key__', '=', rickard_key) expected_matches = 1 # We expect 1, but allow the query to get 1 extra. entities = list(query.fetch(limit=expected_matches + 1)) self.assertEqual(len(entities), expected_matches)
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_allocate_ids(self): num_ids = 10 allocated_keys = datastore.allocate_ids(datastore.Key('Kind'), num_ids) self.assertEqual(len(allocated_keys), num_ids) unique_ids = set() for key in allocated_keys: unique_ids.add(key.id) self.assertEqual(key.name, None) self.assertNotEqual(key.id, None) self.assertEqual(len(unique_ids), num_ids)
def test_mass_delete(self): datastore_mock = Mock() storage = DatastoreStorage(datastore_mock) q_mock = Mock() q_mock.fetch.return_value = [ Mock(key=datastore.Key('task', n, project='test')) for n in range(102) ] datastore_mock.query.return_value = q_mock storage.delete_tasks() assert datastore_mock.delete_multi.call_count == 2
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 _get_post(self, id_or_name=None, post_content=None): post_content = post_content or { 'title': u'How to make the perfect pizza in your grill', 'tags': [u'pizza', u'grill'], 'publishedAt': datetime.datetime(2001, 1, 1, tzinfo=pytz.utc), 'author': u'Silvano', 'isDraft': False, 'wordCount': 400, 'rating': 5.0, } # Create an entity with the given content. entity = datastore.Entity(key=datastore.Key('Post')) entity.update(post_content) # Update the entity key. if id_or_name is not None: entity.key = entity.key.completed_key(id_or_name) return 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)
# See the License for the specific language governing permissions and # limitations under the License. # Welcome to the gCloud Datastore Demo! (hit enter) # We're going to walk through some of the basics... # Don't worry though. You don't need to do anything, just keep hitting enter... # Let's start by importing the demo module and initializing our connection. from gcloud import datastore from gcloud.datastore import demo demo.initialize() # Let's import the package containing our helper classes: # Let's create a new entity of type "Thing" and name it 'Toy': key = datastore.Key('Thing') toy = datastore.Entity(key) toy.update({'name': 'Toy'}) # Now let's save it to our datastore: datastore.put([toy]) # If we look it up by its key, we should find it... print(datastore.get([toy.key])) # And we should be able to delete it... datastore.delete([toy.key]) # Since we deleted it, if we do another lookup it shouldn't be there again: print(datastore.get([toy.key]))
class TestDatastoreSave(TestDatastore): PARENT = datastore.Key('Blog', 'PizzaMan') def _get_post(self, id_or_name=None, post_content=None): post_content = post_content or { 'title': u'How to make the perfect pizza in your grill', 'tags': [u'pizza', u'grill'], 'publishedAt': datetime.datetime(2001, 1, 1, tzinfo=pytz.utc), 'author': u'Silvano', 'isDraft': False, 'wordCount': 400, 'rating': 5.0, } # Create an entity with the given content. # NOTE: Using a parent to ensure consistency for query # in `test_empty_kind`. key = datastore.Key('Post', parent=self.PARENT) entity = datastore.Entity(key=key) entity.update(post_content) # Update the entity key. if id_or_name is not None: entity.key = entity.key.completed_key(id_or_name) return entity def _generic_test_post(self, name=None, key_id=None): entity = self._get_post(id_or_name=(name or key_id)) 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 given and retrieved are the the same. self.assertEqual(retrieved_entity, entity) def test_post_with_name(self): self._generic_test_post(name='post1') def test_post_with_id(self): self._generic_test_post(key_id=123456789) def test_post_with_generated_id(self): self._generic_test_post() 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 test_empty_kind(self): query = datastore.Query(kind='Post') query.ancestor = self.PARENT posts = list(query.fetch(limit=2)) self.assertEqual(posts, [])
def setUpClass(cls): super(TestDatastoreQuery, cls).setUpClass() cls.CHARACTERS = populate_datastore.CHARACTERS cls.ANCESTOR_KEY = datastore.Key(*populate_datastore.ANCESTOR)