def save(self, transactional=False, **kwargs): for field_name, field_obj in self._fields.iteritems(): if isinstance(field_obj, DictField): pre_save_func = getattr(field_obj, 'pre_save') if not pre_save_func: continue value = getattr(self, field_name) if isinstance(value, dict): self._entity[field_name] = pre_save_func(value) global ACTIVE_TRANSACTION global TRANSACTION_ENTITIES if transactional and not GAE_RUNNING: batch = ACTIVE_TRANSACTION if not batch: batch = datastore.Batch()#Transaction() #transaction.begin() ACTIVE_TRANSACTION = batch batch.put(self._entity) TRANSACTION_ENTITIES.append(self._entity) if len(TRANSACTION_ENTITIES) > 200: batch.commit() TRANSACTION_ENTITIES = [] ACTIVE_TRANSACTION = None else: if GAE_RUNNING: self._entity.put() else: datastore.put([self._entity])
def create_report(employee_id, report_id, rows, description): with Transaction(): if _get_report(employee_id, report_id, False) is not None: raise DuplicateReport() report = _upsert_report(employee_id, report_id, rows) report['status'] = 'pending' if description is not None: report['description'] = description report['created'] = report['updated'] = datetime.datetime.utcnow() datastore.put([report])
def reject_report(employee_id, report_id, reason): with Transaction(): report = _get_report(employee_id, report_id, False) if report is None: raise NoSuchReport() if report['status'] != 'pending': raise BadReportStatus(report['status']) report['updated'] = datetime.datetime.utcnow() report['status'] = 'rejected' report['reason'] = reason datastore.put([report])
def _get_report(employee_id, report_id, create=True): key = Key('Employee', employee_id, 'Expense Report', report_id) reports = datastore.get([key]) if len(reports) == 0: if not create: return None report = Entity(key) datastore.put([report]) else: report, = reports return report
def approve_report(employee_id, report_id, check_number): with Transaction(): report = _get_report(employee_id, report_id, False) if report is None: raise NoSuchReport() if report['status'] != 'pending': raise BadReportStatus(report['status']) report['updated'] = datetime.datetime.utcnow() report['status'] = 'paid' report['check_number'] = check_number datastore.put([report])
def _get_employee(employee_id, create=True): key = Key('Employee', employee_id) employees = datastore.get([key]) if len(employees) == 0: if not create: return None employee = Entity(key) employee['created'] = employee['updated'] = datetime.datetime.utcnow() datastore.put([employee]) else: employee, = employees return employee
def update_report(employee_id, report_id, rows, description): with Transaction(): report = _get_report(employee_id, report_id, False) if report is None: raise NoSuchReport() if report['status'] != 'pending': raise BadReportStatus(report['status']) _upsert_report(employee_id, report_id, rows) if description is not None: report['description'] = description report['updated'] = datetime.datetime.utcnow() datastore.put([report])
def _upsert_report(employee_id, report_id, rows): _get_employee(employee_id) # force existence report = _get_report(employee_id, report_id) _purge_report_items(report) # Add items based on rows. report_path = list(report.key.flat_path) for i, row in enumerate(rows): path = report_path + ['Expense Item', i + 1] key = Key(*path) item = Entity(key) for k, v in row.items(): item[k] = v datastore.put([item]) return report
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_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 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 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 _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)
# 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)) # Now let's try a more advanced query. # First, let's create some entities. SAMPLE_DATA = [ (1234, 'Computer', 10), (2345, 'Computer', 8),
# 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)) # Now let's try a more advanced query. # First, let's create some entities. SAMPLE_DATA = [(1234, 'Computer', 10), (2345, 'Computer', 8), (3456, 'Laptop', 10), (4567, 'Printer', 11), (5678, 'Printer', 12), (6789, 'Computer', 13)]
projection=["trial_id"], ).fetch()]) ids.add(0) trial_id = max(ids)+1 perf_test_git_hash = subprocess.check_output(["git", "rev-parse", "HEAD"]).strip().decode("ascii") dt = datastore.Entity(datastore.Key("DownloadTrial")) dt.update({"trial_id": trial_id, "notes": notes, "perf_test_git_hash": perf_test_git_hash, "client_tahoe_appname": tahoe_appname, "client_tahoe_version": tahoe_version, "client_tahoe_branch": tahoe_branch, "client_tahoe_git_hash": tahoe_git_hash, }) datastore.put([dt]) print "-- Starting trial id %d, mode=%s, gridconfig=%d" % (trial_id, mode, grid_config_id) key = datastore.Key("DownloadPerf") if mode == "k60": values_of_filesize = SIZES.keys() values_of_k = SHARES elif mode == "k6": values_of_filesize = SIZES.keys() values_of_k = range(1,6+1) elif mode == "partial-banding": values_of_filesize = [M] values_of_k = range(1,6+1) + [30,60] elif mode == "partial-100MB": values_of_filesize = [100*M]
# 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])) # Now let's try a more advanced query. # First, let's create some entities. SAMPLE_DATA = [(1234, 'Computer', 10), (2345, 'Computer', 8), (3456, 'Laptop', 10), (4567, 'Printer', 11), (5678, 'Printer', 12), (6789, 'Computer', 13)]
# 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])) # Now let's try a more advanced query. # First, let's create some entities. SAMPLE_DATA = [ (1234, 'Computer', 10), (2345, 'Computer', 8),