def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, basestring) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just insert
results.append(datastore.Put(ent))
else:
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
if not was_in_transaction:
# We can cache if we weren't in a transaction before this little nested one
caching.add_entities_to_cache(
self.model,
[ent],
caching.CachingSituation.DATASTORE_GET_PUT,
self.namespace,
)
except:
# Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError(
"Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name,
basestring) and id_or_name.startswith("__"):
raise NotSupportedError(
"Datastore ids cannot start with __. Id was %s" %
id_or_name)
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just insert
results.append(datastore.Put(ent))
else:
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
if not was_in_transaction:
# We can cache if we weren't in a transaction before this little nested one
caching.add_entity_to_cache(
self.model, ent,
caching.CachingSituation.DATASTORE_GET_PUT)
except:
# Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
def insert_chunk(keys, entities):
# Note that this is limited to a maximum of 25 entities.
markers = []
@db.transactional(xg=len(entities) > 1)
def txn():
for key in keys:
if check_existence and key is not None:
if utils.key_exists(key):
raise IntegrityError(
"Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(
id_or_name,
basestring) and id_or_name.startswith("__"):
raise NotSupportedError(
"Datastore ids cannot start with __. Id was %s"
% id_or_name)
# Notify App Engine of any keys we're specifying intentionally
reserve_id(key.kind(), key.id_or_name(),
self.namespace)
results = datastore.Put(entities)
for entity in entities:
markers.extend(constraints.acquire(self.model, entity))
caching.add_entities_to_cache(
self.model,
entities,
caching.CachingSituation.DATASTORE_GET_PUT,
self.namespace,
skip_memcache=True)
return results
try:
return txn()
except:
# There are 3 possible reasons why we've ended up here:
# 1. The datastore.Put() failed, but note that because it's a transaction, the
# exception isn't raised until the END of the transaction block.
# 2. Some of the markers were acquired, but then we hit a unique constraint
# conflict and so the outer transaction was rolled back.
# 3. Something else went wrong after we'd acquired markers, e.g. the
# caching.add_entities_to_cache call got hit by a metaphorical bus.
# In any of these cases, we (may) have acquired markers via (a) nested, independent
# transaction(s), and so we need to release them again.
constraints.release_markers(markers)
raise
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
except:
#Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
entity_post_insert.send(sender=self.model, entity=ent)
def execute(self):
if self.has_pk and not has_concrete_parents(self.model):
results = []
#We are inserting, but we specified an ID, we need to check for existence before we Put()
#We do it in a loop so each check/put is transactional - because it's an ancestor query it shouldn't
#cost any entity groups
for key, ent in zip(self.included_keys, self.entities):
@db.transactional
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, basestring) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
caching.add_entity_to_context_cache(self.model, ent)
except:
#Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
txn()
return results
else:
#FIXME: We should rearrange this so that each entity is handled individually like above. We'll
#lose insert performance, but gain consistency on errors which is more important
markers = constraints.acquire_bulk(self.model, self.entities)
try:
results = datastore.Put(self.entities)
for entity in self.entities:
caching.add_entity_to_context_cache(self.model, entity)
except:
to_delete = chain(*markers)
constraints.release_markers(to_delete)
raise
for ent, m in zip(self.entities, markers):
constraints.update_instance_on_markers(ent, m)
return results
def insert_chunk(keys, entities):
# Note that this is limited to a maximum of 25 entities.
markers = []
@db.transactional(xg=entity_group_count > 1)
def txn():
for key in keys:
if check_existence and key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, six.string_types) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
# Notify App Engine of any keys we're specifying intentionally
reserve_id(key.kind(), key.id_or_name(), self.namespace)
results = perform_insert(entities)
for entity, _ in entities:
markers.extend(constraints.acquire(self.model, entity))
caching.add_entities_to_cache(
self.model,
[x[0] for x in entities],
caching.CachingSituation.DATASTORE_GET_PUT,
self.namespace,
skip_memcache=True
)
return results
try:
return txn()
except:
# There are 3 possible reasons why we've ended up here:
# 1. The rpc.Put() failed, but note that because it's a transaction, the
# exception isn't raised until the END of the transaction block.
# 2. Some of the markers were acquired, but then we hit a unique constraint
# conflict and so the outer transaction was rolled back.
# 3. Something else went wrong after we'd acquired markers, e.g. the
# caching.add_entities_to_cache call got hit by a metaphorical bus.
# In any of these cases, we (may) have acquired markers via (a) nested, independent
# transaction(s), and so we need to release them again.
constraints.release_markers(markers)
raise
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, basestring) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
caching.add_entity_to_context_cache(self.model, ent)
except:
#Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
def execute(self):
if self.has_pk and not has_concrete_parents(self.model):
results = []
#We are inserting, but we specified an ID, we need to check for existence before we Put()
#We do it in a loop so each check/put is transactional - because it's an ancestor query it shouldn't
#cost any entity groups
for key, ent in zip(self.included_keys, self.entities):
@db.transactional
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
except:
#Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
entity_post_insert.send(sender=self.model, entity=ent)
txn()
return results
else:
markers = constraints.acquire_bulk(self.model, self.entities)
try:
results = datastore.Put(self.entities)
except:
to_delete = chain(*markers)
constraints.release_markers(to_delete)
raise
for ent, m in zip(self.entities, markers):
constraints.update_instance_on_markers(ent, m)
entity_post_insert.send(sender=self.model, entity=ent)
return results
def execute(self):
if self.has_pk and not has_concrete_parents(self.model):
results = []
# We are inserting, but we specified an ID, we need to check for existence before we Put()
# We do it in a loop so each check/put is transactional - because it's an ancestor query it shouldn't
# cost any entity groups
was_in_transaction = datastore.IsInTransaction()
for key, ent in zip(self.included_keys, self.entities):
@db.transactional
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, basestring) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just insert
results.append(datastore.Put(ent))
else:
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
if not was_in_transaction:
# We can cache if we weren't in a transaction before this little nested one
caching.add_entity_to_cache(self.model, ent, caching.CachingSituation.DATASTORE_GET_PUT)
except:
# Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
# Make sure we notify app engine that we are using this ID
# FIXME: Copy ancestor across to the template key
reserve_id(key.kind(), key.id_or_name())
txn()
return results
else:
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just bulk insert
results = datastore.Put(self.entities)
for entity in self.entities:
caching.add_entity_to_cache(self.model, entity, caching.CachingSituation.DATASTORE_PUT)
return results
else:
markers = []
try:
#FIXME: We should rearrange this so that each entity is handled individually like above. We'll
# lose insert performance, but gain consistency on errors which is more important
markers = constraints.acquire_bulk(self.model, self.entities)
results = datastore.Put(self.entities)
for entity in self.entities:
caching.add_entity_to_cache(self.model, entity, caching.CachingSituation.DATASTORE_PUT)
except:
to_delete = chain(*markers)
constraints.release_markers(to_delete)
raise
for ent, k, m in zip(self.entities, results, markers):
ent.__key = k
constraints.update_instance_on_markers(ent, m)
return results
def execute(self):
if self.has_pk and not has_concrete_parents(self.model):
results = []
# We are inserting, but we specified an ID, we need to check for existence before we Put()
# We do it in a loop so each check/put is transactional - because it's an ancestor query it shouldn't
# cost any entity groups
for key, ent in zip(self.included_keys, self.entities):
@db.transactional
def txn():
if key is not None:
if utils.key_exists(key):
raise IntegrityError("Tried to INSERT with existing key")
id_or_name = key.id_or_name()
if isinstance(id_or_name, basestring) and id_or_name.startswith("__"):
raise NotSupportedError("Datastore ids cannot start with __. Id was %s" % id_or_name)
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just insert
results.append(datastore.Put(ent))
else:
markers = constraints.acquire(self.model, ent)
try:
results.append(datastore.Put(ent))
caching.add_entity_to_context_cache(self.model, ent)
except:
# Make sure we delete any created markers before we re-raise
constraints.release_markers(markers)
raise
# Make sure we notify app engine that we are using this ID
# FIXME: Copy ancestor across to the template key
id_or_name = key.id_or_name()
if isinstance(id_or_name, (int, long)):
try:
db.allocate_id_range(datastore.Key.from_path(key.kind(), 1), id_or_name, id_or_name)
except:
# We don't re-raise because it's not terminal, but if this happens we need to know why
logging.exception("An error occurred when notifying app engine that an ID has been used. Please report.")
txn()
return results
else:
if not constraints.constraint_checks_enabled(self.model):
# Fast path, just bulk insert
results = datastore.Put(self.entities)
for entity in self.entities:
caching.add_entity_to_context_cache(self.model, entity)
return results
else:
markers = []
try:
#FIXME: We should rearrange this so that each entity is handled individually like above. We'll
# lose insert performance, but gain consistency on errors which is more important
markers = constraints.acquire_bulk(self.model, self.entities)
results = datastore.Put(self.entities)
for entity in self.entities:
caching.add_entity_to_context_cache(self.model, entity)
except:
to_delete = chain(*markers)
constraints.release_markers(to_delete)
raise
for ent, m in zip(self.entities, markers):
constraints.update_instance_on_markers(ent, m)
return results
