py_tasks_melange: comparison thirdparty/google_appengine/google/appengine/api/datastore.py

equal deleted inserted replaced

-:c61d96e72e6f
+:d0b7dac5325c
 for entity, key in zip(entities, keys):
 entity._Entity__key._Key__reference.CopyFrom(key)
 if tx:
 tx.RecordModifiedKeys([e.key() for e in entities], error_on_repeat=False)
+tx.entity_group = entities[0].entity_group()
 if multiple:
 return [Key._FromPb(k) for k in keys]
 else:
 return Key._FromPb(resp.key(0))
 """
 return self.key().entity_group()
 def unindexed_properties(self):
 """Returns this entity's unindexed properties, as a frozenset of strings."""
-return self.__unindexed_properties
+return getattr(self, '_Entity__unindexed_properties', [])
 def __setitem__(self, name, value):
 """Implements the [] operator. Used to set property value(s).
 If the property name is the empty string or not a string, raises
 sample = values
 if isinstance(sample, list):
 sample = values[0]
 if (isinstance(sample, datastore_types._RAW_PROPERTY_TYPES) or
-name in self.__unindexed_properties):
+name in self.unindexed_properties()):
 pb.raw_property_list().extend(properties)
 else:
 pb.property_list().extend(properties)
 if pb.property_size() > _MAX_INDEXED_PROPERTIES:
 Returns:
 # this query
 Query
 """
-key = _GetCompleteKeyOrError(ancestor)
+self.__ancestor = _GetCompleteKeyOrError(ancestor)
-self.__ancestor = datastore_pb.Reference()
-self.__ancestor.CopyFrom(key._Key__reference)
 return self
 def IsKeysOnly(self):
 """Returns True if this query is keys only, false otherwise."""
 return self.__keys_only
 limit and offset must both be integers >= 0.
 This is not intended to be used by application developers. Use Get()
 instead!
 """
-if _CurrentTransactionKey():
-raise datastore_errors.BadRequestError(
-"Can't query inside a transaction.")
 pb = self._ToPb(limit, offset)
 result = datastore_pb.QueryResult()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'RunQuery', pb, result)
 yaml = datastore_index.IndexYamlForQuery(
 *datastore_index.CompositeIndexForQuery(pb)[1:-1])
 raise datastore_errors.NeedIndexError(
 str(exc) + '\nThis query needs this index:\n' + yaml)
-return Iterator._FromPb(result)
+return Iterator(result)
 def Get(self, limit, offset=0):
 """Fetches and returns a maximum number of results from the query.
 This method fetches and returns a list of resulting entities that matched
 if not isinstance(offset, (int, long)) or offset < 0:
 raise datastore_errors.BadArgumentError(
 'Argument to Get named \'offset\' must be an int greater than or '
 'equal to 0; received %s (a %s)' % (offset, typename(offset)))
-return self._Run(limit, offset)._Next(limit)
+return self._Run(limit, offset)._Get(limit)
 def Count(self, limit=None):
 """Returns the number of entities that this query matches. The returned
 count is cached; successive Count() calls will not re-scan the datastore
 unless the query is changed.
 offset: int
 Returns:
 # the PB representation of this Query
 datastore_pb.Query
-"""
+Raises:
+BadRequestError if called inside a transaction and the query does not
+include an ancestor.
+"""
+if not self.__ancestor and _CurrentTransactionKey():
+raise datastore_errors.BadRequestError(
+'Only ancestor queries are allowed inside transactions.')
 pb = datastore_pb.Query()
+_MaybeSetupTransaction(pb, [self.__ancestor])
 pb.set_kind(self.__kind.encode('utf-8'))
 pb.set_keys_only(bool(self.__keys_only))
 if self.__app:
 pb.set_app(self.__app.encode('utf-8'))
 if limit is not None:
 pb.set_limit(limit)
 if offset is not None:
 pb.set_offset(offset)
 if self.__ancestor:
-pb.mutable_ancestor().CopyFrom(self.__ancestor)
+pb.mutable_ancestor().CopyFrom(self.__ancestor._Key__reference)
 if ((self.__hint == self.ORDER_FIRST and self.__orderings) or
 (self.__hint == self.ANCESTOR_FIRST and self.__ancestor) or
 (self.__hint == self.FILTER_FIRST and len(self) > 0)):
 pb.set_hint(self.__hint)
 > it = Query('Person').Run()
 > for person in it:
 >   print 'Hi, %s!' % person['name']
 """
-def __init__(self, cursor, keys_only=False):
+def __init__(self, query_result_pb):
-self.__cursor = cursor
+self.__cursor = query_result_pb.cursor()
-self.__buffer = []
+self.__keys_only = query_result_pb.keys_only()
-self.__more_results = True
+self.__buffer = self._ProcessQueryResult(query_result_pb)
-self.__keys_only = keys_only
+def _Get(self, count):
+"""Gets the next count result(s) of the query.
+Not intended to be used by application developers. Use the python
+iterator protocol instead.
+This method uses _Next to returns the next entities or keys from the list of
+matching results. If the query specified a sort order, results are returned
+in that order. Otherwise, the order is undefined.
+The argument, count, specifies the number of results to return. However, the
+length of the returned list may be smaller than count. This is the case only
+if count is greater than the number of remaining results.
+The results are always returned as a list. If there are no results left,
+an empty list is returned.
+Args:
+# the number of results to return; must be >= 1
+count: int or long
+Returns:
+# a list of entities or keys
+[Entity or Key, ...]
+"""
+entityList = self._Next(count)
+while len(entityList) < count and self.__more_results:
+next_results = self._Next(count - len(entityList))
+if not next_results:
+break
+entityList += next_results
+return entityList;
 def _Next(self, count):
 """Returns the next result(s) of the query.
 Not intended to be used by application developers. Use the python
 This method returns the next entities or keys from the list of matching
 results. If the query specified a sort order, results are returned in that
 order. Otherwise, the order is undefined.
-The argument specifies the number of results to return. If it's greater
+The argument, count, specifies the number of results to return. However, the
-than the number of remaining results, all of the remaining results are
+length of the returned list may be smaller than count. This is the case if
-returned. In that case, the length of the returned list will be smaller
+count is greater than the number of remaining results or the size of the
-than count.
+remaining results exciteds the RPC buffer limit. Use _Get to insure all
+possible entities are retrieved.
 There is an internal buffer for use with the next() method. If this buffer
 is not empty, up to 'count' values are removed from this buffer and
 returned. It's best not to mix _Next() and next().
 raise datastore_errors.BadArgumentError(
 'Argument to _Next must be an int greater than 0; received %s (a %s)' %
 (count, typename(count)))
 if self.__buffer:
-raise datastore_errors.BadRequestError(
+if count <= len(self.__buffer):
-'You can\'t mix next() and _Next()')
+entity_list = self.__buffer[:count]
+del self.__buffer[:count]
+return entity_list
+else:
+entity_list = self.__buffer
+self.__buffer = []
+count -= len(entity_list)
+else:
+entity_list=[]
 if not self.__more_results:
-return []
+return entity_list
 req = datastore_pb.NextRequest()
 req.set_count(count)
-req.mutable_cursor().CopyFrom(self._ToPb())
+req.mutable_cursor().CopyFrom(self.__cursor)
 result = datastore_pb.QueryResult()
 try:
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'Next', req, result)
 except apiproxy_errors.ApplicationError, err:
 raise _ToDatastoreError(err)
+return entity_list + self._ProcessQueryResult(result)
+def _ProcessQueryResult(self, result):
+"""Returns all results from datastore_pb.QueryResult and updates
+self.__more_results
+Not intended to be used by application developers. Use the python
+iterator protocol instead.
+The results are always returned as a list. If there are no results left,
+an empty list is returned.
+Args:
+# the instance of datastore_pb.QueryResult to be stored
+result: datastore_pb.QueryResult
+Returns:
+# a list of entities or keys
+[Entity or Key, ...]
+"""
 self.__more_results = result.more_results()
 if self.__keys_only:
 return [Key._FromPb(e.key()) for e in result.result_list()]
 else:
 return self.__buffer.pop(0)
 except IndexError:
 raise StopIteration
 def __iter__(self): return self
-def _ToPb(self):
-"""Converts this Iterator to its protocol buffer representation. Not
-intended to be used by application developers. Enforced by hiding the
-datastore_pb classes.
-Returns:
-# the PB representation of this Iterator
-datastore_pb.Cursor
-"""
-pb = datastore_pb.Cursor()
-pb.set_cursor(self.__cursor)
-return pb
-@staticmethod
-def _FromPb(pb):
-"""Static factory method. Returns the Iterator representation of the given
-protocol buffer (datastore_pb.QueryResult). Not intended to be used by
-application developers. Enforced by hiding the datastore_pb classes.
-Args:
-pb: datastore_pb.QueryResult
-Returns:
-Iterator
-"""
-return Iterator(pb.cursor().cursor(), keys_only=pb.keys_only())
 class _Transaction(object):
 """Encapsulates a transaction currently in progress.
 If we've sent a BeginTransaction call, then handle will be a
 self.modified_keys = set()
 def RecordModifiedKeys(self, keys, error_on_repeat=True):
 """Updates the modified keys seen so far.
-Also sets entity_group if it hasn't yet been set.
 If error_on_repeat is True and any of the given keys have already been
 modified, raises BadRequestError.
 Args:
 keys: sequence of Keys
 """
 keys, _ = NormalizeAndTypeCheckKeys(keys)
-if keys and not self.entity_group:
-self.entity_group = keys[0].entity_group()
 keys = set(keys)
 if error_on_repeat:
 already_modified = self.modified_keys.intersection(keys)
 if already_modified:
 Raises BadRequestError if the entity has a different entity group than the
 current transaction.
 Args:
-request: GetRequest, PutRequest, or DeleteRequest
+request: GetRequest, PutRequest, DeleteRequest, or Query
 keys: sequence of Keys
 Returns:
 _Transaction if we're inside a transaction, otherwise None
 """
 assert isinstance(request, (datastore_pb.GetRequest, datastore_pb.PutRequest,
-datastore_pb.DeleteRequest))
+datastore_pb.DeleteRequest, datastore_pb.Query))
 tx_key = None
 try:
 tx_key = _CurrentTransactionKey()
 if tx_key:
 groups = [k.entity_group() for k in keys]
 if tx.entity_group:
 expected_group = tx.entity_group
 else:
 expected_group = groups[0]
 for group in groups:
 if (group != expected_group or
 (not group.has_id_or_name() and group is not expected_group)):
 raise _DifferentEntityGroupError(expected_group, group)
+if not tx.entity_group and group.has_id_or_name():
+tx.entity_group = group
 if not tx.handle:
 tx.handle = datastore_pb.Transaction()
 req = api_base_pb.VoidProto()
 apiproxy_stub_map.MakeSyncCall('datastore_v3', 'BeginTransaction', req,

changeset 2413	d0b7dac5325c
parent 2309	be1b94099f2d
child 2864	2e0b0af889be