def Run(self, limit, offset):
opts = self._gae_query._Query__query_options
if opts.keys_only or opts.projection:
return self._gae_query.Run(limit=limit, offset=offset)
ret = caching.get_from_cache(self._identifier, self._namespace)
if ret is not None and not utils.entity_matches_query(ret, self._gae_query):
ret = None
if ret is None:
# We do a fast keys_only query to get the result
keys_query = Query(self._gae_query._Query__kind, keys_only=True, namespace=self._namespace)
keys_query.update(self._gae_query)
keys = keys_query.Run(limit=limit, offset=offset)
# Do a consistent get so we don't cache stale data, and recheck the result matches the query
ret = [x for x in datastore.Get(keys) if x and utils.entity_matches_query(x, self._gae_query)]
if len(ret) == 1:
caching.add_entities_to_cache(
self._model,
[ret[0]],
caching.CachingSituation.DATASTORE_GET,
self._namespace,
)
return iter(ret)
return iter([ret])
def Run(self, limit, offset):
opts = self._gae_query._Query__query_options
if opts.keys_only or opts.projection:
return self._gae_query.Run(limit=limit, offset=offset)
ret = caching.get_from_cache(self._identifier)
if ret is not None and not utils.entity_matches_query(
ret, self._gae_query):
ret = None
if ret is None:
# We do a fast keys_only query to get the result
keys_query = Query(self._gae_query._Query__kind, keys_only=True)
keys_query.update(self._gae_query)
keys = keys_query.Run(limit=limit, offset=offset)
# Do a consistent get so we don't cache stale data, and recheck the result matches the query
ret = [
x for x in datastore.Get(keys)
if utils.entity_matches_query(x, self._gae_query)
]
if len(ret) == 1:
caching.add_entity_to_cache(
self._model, ret[0],
caching.CachingSituation.DATASTORE_GET)
return iter(ret)
return iter([ret])
def _build_gae_query(self):
""" Build and return the Datastore Query object. """
query_kwargs = {
"kind": str(self.db_table)
}
if self.distinct:
if self.projection:
query_kwargs["distinct"] = True
else:
logging.warning("Ignoring distinct on a query where a projection wasn't possible")
if self.keys_only:
query_kwargs["keys_only"] = self.keys_only
elif self.projection:
query_kwargs["projection"] = self.projection
query = Query(
**query_kwargs
)
if has_concrete_parents(self.model) and not self.model._meta.proxy:
query["class ="] = self.model._meta.db_table
ordering = []
for order in self.ordering:
if isinstance(order, (long, int)):
direction = datastore.Query.ASCENDING if order == 1 else datastore.Query.DESCENDING
order = self.queried_fields[0]
else:
direction = datastore.Query.DESCENDING if order.startswith("-") else datastore.Query.ASCENDING
order = order.lstrip("-")
if order == self.model._meta.pk.column or order == "pk":
order = "__key__"
#Flip the ordering if someone called reverse() on the queryset
if not self.original_query.standard_ordering:
direction = datastore.Query.DESCENDING if direction == datastore.Query.ASCENDING else datastore.Query.ASCENDING
ordering.append((order, direction))
def process_and_branch(query, and_branch):
for child in and_branch[-1]:
column, op, value = child[1]
# for column, op, value in and_branch[-1]:
if column == self.pk_col:
column = "__key__"
#FIXME: This EmptyResultSet check should happen during normalization so that Django doesn't count it as a query
if op == "=" and "__key__ =" in query and query["__key__ ="] != value:
# We've already done an exact lookup on a key, this query can't return anything!
raise EmptyResultSet()
if not isinstance(value, datastore.Key):
value = get_datastore_key(self.model, value)
key = "%s %s" % (column, op)
try:
if isinstance(value, basestring):
value = coerce_unicode(value)
if key in query:
if type(query[key]) == list:
if value not in query[key]:
query[key].append(value)
else:
if query[key] != value:
query[key] = [ query[key], value ]
else:
query[key] = value
except datastore_errors.BadFilterError as e:
raise NotSupportedError(str(e))
if self.where:
queries = []
# print query._Query__kind, self.where
for and_branch in self.where[1]:
# Duplicate the query for all the "OR"s
queries.append(Query(**query_kwargs))
queries[-1].update(query) # Make sure we copy across filters (e.g. class =)
try:
if and_branch[0] == "LIT":
and_branch = ("AND", [and_branch])
process_and_branch(queries[-1], and_branch)
except EmptyResultSet:
# This is a little hacky but basically if there is only one branch in the or, and it raises
# and EmptyResultSet, then we just bail, however if there is more than one branch the query the
# query might still return something. This logic needs cleaning up and moving to the DNF phase
if len(self.where[1]) == 1:
return NoOpQuery()
else:
queries.pop()
if not queries:
return NoOpQuery()
included_pks = [ qry["__key__ ="] for qry in queries if "__key__ =" in qry ]
if len(included_pks) == len(queries): # If all queries have a key, we can perform a Get
return QueryByKeys(self.model, queries, ordering) # Just use whatever query to determine the matches
else:
if len(queries) > 1:
# Disable keys only queries for MultiQuery
new_queries = []
for i, query in enumerate(queries):
if i > 30:
raise NotSupportedError("Too many subqueries (max: 30, got {}). Probably cause too many IN/!= filters".format(
len(queries)
))
qry = Query(query._Query__kind, projection=query._Query__query_options.projection)
qry.update(query)
try:
qry.Order(*ordering)
except datastore_errors.BadArgumentError as e:
raise NotSupportedError(e)
new_queries.append(qry)
query = datastore.MultiQuery(new_queries, ordering)
else:
query = queries[0]
try:
query.Order(*ordering)
except datastore_errors.BadArgumentError as e:
raise NotSupportedError(e)
else:
try:
query.Order(*ordering)
except datastore_errors.BadArgumentError as e:
raise NotSupportedError(e)
# If the resulting query was unique, then wrap as a unique query which
# will hit the cache first
unique_identifier = query_is_unique(self.model, query)
if unique_identifier:
return UniqueQuery(unique_identifier, query, self.model)
DJANGAE_LOG.debug("Select query: {0}, {1}".format(self.model.__name__, self.where))
return query
def _fetch_results(self, query):
# If we're manually excluding PKs, and we've specified a limit to the results
# we need to make sure that we grab more than we were asked for otherwise we could filter
# out too many! These are again limited back to the original request limit
# while we're processing the results later
high_mark = self.query.high_mark
low_mark = self.query.low_mark
excluded_pk_count = 0
if self.excluded_pks and high_mark:
excluded_pk_count = len(self.excluded_pks)
high_mark += excluded_pk_count
limit = None if high_mark is None else (high_mark - (low_mark or 0))
offset = low_mark or 0
if self.query.kind == "COUNT":
if self.excluded_pks:
# If we're excluding pks, relying on a traditional count won't work
# so we have two options:
# 1. Do a keys_only query instead and count the results excluding keys
# 2. Do a count, then a pk__in=excluded_pks to work out how many to subtract
# Here I've favoured option one as it means a single RPC call. Testing locally
# didn't seem to indicate much of a performance difference, even when doing the pk__in
# with GetAsync while the count was running. That might not be true of prod though so
# if anyone comes up with a faster idea let me know!
count_query = Query(query._Query__kind, keys_only=True)
count_query.update(query)
resultset = count_query.Run(limit=limit, offset=offset)
self.results = (x for x in [len([y for y in resultset if y not in self.excluded_pks])])
else:
self.results = (x for x in [query.Count(limit=limit, offset=offset)])
return
elif self.query.kind == "AVERAGE":
raise ValueError("AVERAGE not yet supported")
else:
self.results = query.Run(limit=limit, offset=offset)
# Ensure that the results returned is reset
self.results_returned = 0
def increment_returned_results(result):
self.results_returned += 1
return result
def convert_key_to_entity(result):
class FakeEntity(dict):
def __init__(self, key):
self._key = key
def key(self):
return self._key
return FakeEntity(result)
def rename_pk_field(result):
if result is None:
return result
value = result.key().id_or_name()
result[self.query.model._meta.pk.column] = value
result[self.query.concrete_model._meta.pk.column] = value
return result
def process_extra_selects(result):
"""
We handle extra selects by generating the new columns from
each result. We can handle simple boolean logic and operators.
"""
extra_selects = self.query.extra_selects
model_fields = self.query.model._meta.fields
DATE_FORMATS = ("%Y-%m-%d", "%Y-%m-%d %H:%M:%S")
def process_arg(arg):
if arg.startswith("'") and arg.endswith("'"):
# String literal
arg = arg.strip("'")
# Check to see if this is a date
for date in DATE_FORMATS:
try:
value = datetime.strptime(arg, date)
return value
except ValueError:
continue
return arg
elif arg in [x.column for x in model_fields]:
# Column value
return result.get(arg)
# Handle NULL
if arg.lower() == "null":
return None
elif arg.lower() == "true":
return True
elif arg.lower() == "false":
return False
# See if it's an integer
try:
arg = int(arg)
except (TypeError, ValueError):
pass
# Just a plain old literal
return arg
for col, select in extra_selects:
result[col] = select[0](*[process_arg(x) for x in select[1]])
return result
def convert_datetime_fields(result):
fields = [
x
for x in self.query.model._meta.fields
if x.get_internal_type() in ("DateTimeField", "DateField", "TimeField")
]
for field in fields:
column = field.column
if isinstance(result, dict): # sometimes it's a key!
value = result.get(column)
else:
value = None
if value is not None:
result[column] = ensure_datetime(value)
return result
def ignore_excluded_pks(result):
if result.key() in self.query.excluded_pks:
return None
return result
self.results = wrap_result_with_functor(self.results, increment_returned_results)
# If this is a keys only query, we need to generate a fake entity
# for each key in the result set
if self.keys_only:
self.results = wrap_result_with_functor(self.results, convert_key_to_entity)
self.results = wrap_result_with_functor(self.results, ignore_excluded_pks)
self.results = wrap_result_with_functor(self.results, convert_datetime_fields)
self.results = wrap_result_with_functor(self.results, rename_pk_field)
self.results = wrap_result_with_functor(self.results, process_extra_selects)
if self.query.distinct and self.query.extra_selects:
# If we had extra selects, and we're distinct, we must deduplicate results
def deduper_factory():
seen = set()
def dedupe(result):
# FIXME: This logic can't be right. I think we need to store the distinct fields
# somewhere on the query
if getattr(self.original_query, "annotation_select", None):
columns = self.original_query.annotation_select.keys()
else:
columns = self.query.columns or []
if not columns:
return result
key = tuple([result[x] for x in self._exclude_pk(columns) if x in result])
if key in seen:
return None
seen.add(key)
return result
return dedupe
self.results = wrap_result_with_functor(self.results, deduper_factory())
def _fetch_results(self, query):
# If we're manually excluding PKs, and we've specified a limit to the results
# we need to make sure that we grab more than we were asked for otherwise we could filter
# out too many! These are again limited back to the original request limit
# while we're processing the results later
high_mark = self.query.high_mark
low_mark = self.query.low_mark
excluded_pk_count = 0
if self.excluded_pks and high_mark:
excluded_pk_count = len(self.excluded_pks)
high_mark += excluded_pk_count
limit = None if high_mark is None else (high_mark - (low_mark or 0))
offset = low_mark or 0
if self.query.kind == "COUNT":
if self.excluded_pks:
# If we're excluding pks, relying on a traditional count won't work
# so we have two options:
# 1. Do a keys_only query instead and count the results excluding keys
# 2. Do a count, then a pk__in=excluded_pks to work out how many to subtract
# Here I've favoured option one as it means a single RPC call. Testing locally
# didn't seem to indicate much of a performance difference, even when doing the pk__in
# with GetAsync while the count was running. That might not be true of prod though so
# if anyone comes up with a faster idea let me know!
count_query = Query(query._Query__kind, keys_only=True)
count_query.update(query)
resultset = count_query.Run(limit=limit, offset=offset)
self.results = (x for x in [
len([y for y in resultset if y not in self.excluded_pks])
])
else:
self.results = (
x for x in [query.Count(limit=limit, offset=offset)])
return
elif self.query.kind == "AVERAGE":
raise ValueError("AVERAGE not yet supported")
else:
self.results = query.Run(limit=limit, offset=offset)
# Ensure that the results returned is reset
self.results_returned = 0
def increment_returned_results(result):
self.results_returned += 1
return result
def convert_key_to_entity(result):
class FakeEntity(dict):
def __init__(self, key):
self._key = key
def key(self):
return self._key
return FakeEntity(result)
def rename_pk_field(result):
if result is None:
return result
value = result.key().id_or_name()
result[self.query.model._meta.pk.column] = value
result[self.query.concrete_model._meta.pk.column] = value
return result
def process_extra_selects(result):
"""
We handle extra selects by generating the new columns from
each result. We can handle simple boolean logic and operators.
"""
extra_selects = self.query.extra_selects
model_fields = self.query.model._meta.fields
DATE_FORMATS = ("%Y-%m-%d", "%Y-%m-%d %H:%M:%S")
def process_arg(arg):
if arg.startswith("'") and arg.endswith("'"):
# String literal
arg = arg.strip("'")
# Check to see if this is a date
for date in DATE_FORMATS:
try:
value = datetime.strptime(arg, date)
return value
except ValueError:
continue
return arg
elif arg in [x.column for x in model_fields]:
# Column value
return result.get(arg)
# Handle NULL
if arg.lower() == 'null':
return None
elif arg.lower() == 'true':
return True
elif arg.lower() == 'false':
return False
# See if it's an integer
try:
arg = int(arg)
except (TypeError, ValueError):
pass
# Just a plain old literal
return arg
for col, select in extra_selects:
result[col] = select[0](*[process_arg(x) for x in select[1]])
return result
def convert_datetime_fields(result):
fields = [
x for x in self.query.model._meta.fields
if x.get_internal_type() in ("DateTimeField", "DateField",
"TimeField")
]
for field in fields:
column = field.column
if isinstance(result, dict): # sometimes it's a key!
value = result.get(column)
else:
value = None
if value is not None:
result[column] = ensure_datetime(value)
return result
def ignore_excluded_pks(result):
if result.key() in self.query.excluded_pks:
return None
return result
self.results = wrap_result_with_functor(self.results,
increment_returned_results)
# If this is a keys only query, we need to generate a fake entity
# for each key in the result set
if self.keys_only:
self.results = wrap_result_with_functor(self.results,
convert_key_to_entity)
self.results = wrap_result_with_functor(self.results,
ignore_excluded_pks)
self.results = wrap_result_with_functor(self.results,
convert_datetime_fields)
self.results = wrap_result_with_functor(self.results, rename_pk_field)
self.results = wrap_result_with_functor(self.results,
process_extra_selects)
if self.query.distinct and self.query.extra_selects:
# If we had extra selects, and we're distinct, we must deduplicate results
def deduper_factory():
seen = set()
def dedupe(result):
# FIXME: This logic can't be right. I think we need to store the distinct fields
# somewhere on the query
if getattr(self.original_query, "annotation_select", None):
columns = self.original_query.annotation_select.keys()
else:
columns = self.query.columns or []
if not columns:
return result
key = tuple([
result[x] for x in self._exclude_pk(columns)
if x in result
])
if key in seen:
return None
seen.add(key)
return result
return dedupe
self.results = wrap_result_with_functor(self.results,
deduper_factory())
def _fetch_results(self, query):
# If we're manually excluding PKs, and we've specified a limit to the results
# we need to make sure that we grab more than we were asked for otherwise we could filter
# out too many! These are again limited back to the original request limit
# while we're processing the results later
# Apply the namespace before excluding
excluded_pks = [
datastore.Key.from_path(x.kind(), x.id_or_name(), namespace=self.namespace)
for x in self.query.excluded_pks
]
high_mark = self.query.high_mark
low_mark = self.query.low_mark
excluded_pk_count = 0
if excluded_pks and high_mark:
excluded_pk_count = len(excluded_pks)
high_mark += excluded_pk_count
limit = None if high_mark is None else (high_mark - (low_mark or 0))
offset = low_mark or 0
if self.query.kind == "COUNT":
if excluded_pks:
# If we're excluding pks, relying on a traditional count won't work
# so we have two options:
# 1. Do a keys_only query instead and count the results excluding keys
# 2. Do a count, then a pk__in=excluded_pks to work out how many to subtract
# Here I've favoured option one as it means a single RPC call. Testing locally
# didn't seem to indicate much of a performance difference, even when doing the pk__in
# with GetAsync while the count was running. That might not be true of prod though so
# if anyone comes up with a faster idea let me know!
if isinstance(query, QueryByKeys):
# If this is a QueryByKeys, just do the datastore Get and count the results
resultset = (x.key() for x in query.Run(limit=limit, offset=offset) if x)
else:
count_query = Query(query._Query__kind, keys_only=True, namespace=self.namespace)
count_query.update(query)
resultset = count_query.Run(limit=limit, offset=offset)
self.results = [ len([ y for y in resultset if y not in excluded_pks]) ]
self.results_returned = 1
else:
self.results = [query.Count(limit=limit, offset=offset)]
self.results_returned = 1
return
elif self.query.kind == "AVERAGE":
raise ValueError("AVERAGE not yet supported")
# Ensure that the results returned is reset
self.results_returned = 0
self.results = []
seen = set()
def dedupe(result):
# FIXME: This logic can't be right. I think we need to store the distinct fields
# somewhere on the query
if getattr(self.original_query, "annotation_select", None):
columns = self.original_query.annotation_select.keys()
else:
columns = self.query.columns or []
if not columns:
return result
key = tuple([ result[x] for x in self._exclude_pk(columns) if x in result ])
if key in seen:
return None
seen.add(key)
return result
for entity in query.Run(limit=limit, offset=offset):
# If this is a keys only query, we need to generate a fake entity
# for each key in the result set
if self.keys_only:
entity = EntityTransforms.convert_key_to_entity(entity)
entity = EntityTransforms.ignore_excluded_pks(excluded_pks, entity)
entity = EntityTransforms.convert_datetime_fields(self.query, entity)
entity = EntityTransforms.rename_pk_field(self.query.model, self.query.concrete_model, entity)
entity = EntityTransforms.process_extra_selects(self.query, entity)
if self.query.distinct and self.query.extra_selects:
entity = dedupe(entity)
if entity:
self.results.append(entity)
self.results_returned += 1
if limit and self.results_returned >= (limit - excluded_pk_count):
break
def _fetch_results(self, query):
# If we're manually excluding PKs, and we've specified a limit to the results
# we need to make sure that we grab more than we were asked for otherwise we could filter
# out too many! These are again limited back to the original request limit
# while we're processing the results later
# Apply the namespace before excluding
excluded_pks = [
rpc.Key.from_path(x.kind(), x.id_or_name(), namespace=self.namespace)
for x in self.query.excluded_pks
]
high_mark = self.query.high_mark
low_mark = self.query.low_mark
excluded_pk_count = 0
if excluded_pks and high_mark:
excluded_pk_count = len(excluded_pks)
high_mark += excluded_pk_count
limit = None if high_mark is None else (high_mark - (low_mark or 0))
offset = low_mark or 0
if self.query.kind == "COUNT":
if excluded_pks:
# If we're excluding pks, relying on a traditional count won't work
# so we have two options:
# 1. Do a keys_only query instead and count the results excluding keys
# 2. Do a count, then a pk__in=excluded_pks to work out how many to subtract
# Here I've favoured option one as it means a single RPC call. Testing locally
# didn't seem to indicate much of a performance difference, even when doing the pk__in
# with GetAsync while the count was running. That might not be true of prod though so
# if anyone comes up with a faster idea let me know!
if isinstance(query, meta_queries.QueryByKeys):
# If this is a QueryByKeys, just do the datastore Get and count the results
resultset = (x.key() for x in query.Run(limit=limit, offset=offset) if x)
else:
count_query = Query(
query._Query__kind, keys_only=True, namespace=self.namespace
)
count_query.update(query)
resultset = count_query.Run(limit=limit, offset=offset)
self.results = [len([y for y in resultset if y not in excluded_pks])]
self.results_returned = 1
else:
self.results = [query.Count(limit=limit, offset=offset)]
self.results_returned = 1
return
elif self.query.kind == "AVERAGE":
raise ValueError("AVERAGE not yet supported")
# Ensure that the results returned is reset
self.results_returned = 0
self.results = []
seen = set()
def dedupe(result):
# FIXME: This logic can't be right. I think we need to store the distinct fields
# somewhere on the query
if getattr(self.original_query, "annotation_select", None):
columns = self.original_query.annotation_select.keys()
else:
columns = self.query.columns or []
if not columns:
return result
key = tuple([result[x] for x in self._exclude_pk(columns) if x in result])
if key in seen:
return None
seen.add(key)
return result
for entity in query.Run(limit=limit, offset=offset):
# If this is a keys only query, we need to generate a fake entity
# for each key in the result set
if self.keys_only:
entity = EntityTransforms.convert_key_to_entity(entity)
entity = EntityTransforms.ignore_excluded_pks(excluded_pks, entity)
entity = EntityTransforms.convert_datetime_fields(self.query, entity)
entity = EntityTransforms.fix_projected_values_type(self.query, entity)
entity = EntityTransforms.rename_pk_field(
self.query.model, self.query.concrete_model, entity
)
entity = EntityTransforms.process_extra_selects(self.query, entity)
if self.query.distinct and self.query.extra_selects:
entity = dedupe(entity)
if entity:
self.results.append(entity)
self.results_returned += 1
if limit and self.results_returned >= (limit - excluded_pk_count):
break
def _build_gae_query(self):
""" Build and return the Datstore Query object. """
query_kwargs = {
"kind": str(self.db_table)
}
if self.distinct:
query_kwargs["distinct"] = True
if self.keys_only:
query_kwargs["keys_only"] = self.keys_only
elif self.projection:
query_kwargs["projection"] = self.projection
query = Query(
**query_kwargs
)
if has_concrete_parents(self.model) and not self.model._meta.proxy:
query["class ="] = self.model._meta.db_table
ordering = []
for order in self.ordering:
if isinstance(order, int):
direction = datastore.Query.ASCENDING if order == 1 else datastore.Query.DESCENDING
order = self.queried_fields[0]
else:
direction = datastore.Query.DESCENDING if order.startswith("-") else datastore.Query.ASCENDING
order = order.lstrip("-")
if order == self.model._meta.pk.column or order == "pk":
order = "__key__"
ordering.append((order, direction))
def process_and_branch(query, and_branch):
for column, op, value in and_branch[-1]:
if column == self.pk_col:
column = "__key__"
#FIXME: This EmptyResultSet check should happen during normalization so that Django doesn't count it as a query
if op == "=" and "__key__ =" in query:
#We've already done an exact lookup on a key, this query can't return anything!
raise EmptyResultSet()
if not isinstance(value, datastore.Key):
value = get_datastore_key(self.model, value)
key = "%s %s" % (column, op)
if key in query:
query[key] = [ query[key], value ]
else:
query[key] = value
if self.where:
queries = []
#If there is a single filter, we make it out it's an OR with only one branch
#just so that the code below is simpler
if isinstance(self.where, tuple) and len(self.where) == 3:
self.where = ('OR', [(u'AND', [ self.where ])])
elif isinstance(self.where, tuple) and self.where[0] == 'AND':
self.where = ('OR', [self.where])
elif isinstance(self.where, tuple) and self.where[0] == 'OR' and isinstance(self.where[1][0], tuple) and self.where[1][0][0] != 'AND':
self.where = ('OR', [ ('AND', [x]) for x in self.where[-1] ])
operator = self.where[0]
assert operator == 'OR'
#print query._Query__kind, self.where
for and_branch in self.where[1]:
#Duplicate the query for all the "OR"s
queries.append(Query(**query_kwargs))
queries[-1].update(query) #Make sure we copy across filters (e.g. class =)
try:
process_and_branch(queries[-1], and_branch)
except EmptyResultSet:
return NoOpQuery()
def all_queries_same_except_key(_queries):
"""
Returns True if all queries in the list of queries filter on the same thing
except for "__key__ =". Determine if we can do a Get basically.
"""
test = _queries[0]
for qry in _queries:
if "__key__ =" not in qry.keys():
return False
if qry._Query__kind != test._Query__kind:
return False
if qry.keys() != test.keys():
return False
for k, v in qry.items():
if k.startswith("__key__"):
continue
if v != test[k]:
return False
return True
if all_queries_same_except_key(queries):
included_pks = [ qry["__key__ ="] for qry in queries ]
return QueryByKeys(queries[0], included_pks, ordering) #Just use whatever query to determine the matches
else:
if len(queries) > 1:
#Disable keys only queries for MultiQuery
new_queries = []
for query in queries:
qry = Query(query._Query__kind, projection=query._Query__query_options.projection)
qry.update(query)
new_queries.append(qry)
query = datastore.MultiQuery(new_queries, ordering)
else:
query = queries[0]
query.Order(*ordering)
else:
query.Order(*ordering)
#If the resulting query was unique, then wrap as a unique query which
#will hit the cache first
unique_identifier = query_is_unique(self.model, query)
if unique_identifier:
return UniqueQuery(unique_identifier, query, self.model)
DJANGAE_LOG.debug("Select query: {0}, {1}".format(self.model.__name__, self.where))
return query
