def query(self):
from simpledb.query import SimpleDBQuery
manager = mock.Mock()
return SimpleDBQuery(manager, M, None)
def __init__(self, compiler, fields):
super(BackendQuery, self).__init__(compiler, fields)
# TODO: add your initialization code here
domain = domain_for_model(self.query.model)
self.db_query = SimpleDBQuery(
self.connection.create_manager(domain), self.query.model)
def __init__(self, compiler, fields):
super(BackendQuery, self).__init__(compiler, fields)
# TODO: add your initialization code here
domain = domain_for_model(self.query.model)
self.db_query = SimpleDBQuery(self.connection.create_manager(domain),
self.query.model)
class BackendQuery(NonrelQuery):
def __init__(self, compiler, fields):
super(BackendQuery, self).__init__(compiler, fields)
# TODO: add your initialization code here
domain = domain_for_model(self.query.model)
self.db_query = SimpleDBQuery(
self.connection.create_manager(domain), self.query.model)
# This is needed for debugging
def __repr__(self):
# TODO: add some meaningful query string for debugging
return '<BackendQuery: %s>' % self.query.model._meta.db_table
@safe_call
def fetch(self, low_mark=None, high_mark=None):
reslice = 0
if high_mark > AWS_MAX_RESULT_SIZE:
logger.warn('Requested result size %s, assuming infinite' % (
high_mark))
reslice = high_mark
high_mark = None
# TODO: run your low-level query here
#low_mark, high_mark = self.limits
if high_mark is None:
# Infinite fetching
results = self.db_query.fetch_infinite(offset=low_mark)
if reslice:
results = list(results)[:reslice]
elif high_mark > low_mark:
# Range fetching
results = self.db_query.fetch_range(high_mark - low_mark, low_mark)
else:
results = ()
for entity in results:
entity[self.query.get_meta().pk.column] = entity['_id']
del entity['_id']
yield entity
@safe_call
def count(self, limit=None):
# TODO: implement this
return self.db_query.count(limit)
@safe_call
def delete(self):
self.db_query.delete()
@safe_call
def order_by(self, ordering):
# TODO: implement this
for order in ordering:
if order.startswith('-'):
column, direction = order[1:], 'DESC'
else:
column, direction = order, 'ASC'
if column == self.query.get_meta().pk.column:
column = '_id'
self.db_query.add_ordering(column, direction)
# This function is used by the default add_filters() implementation which
# only supports ANDed filter rules and simple negation handling for
# transforming OR filters to AND filters:
# NOT (a OR b) => (NOT a) AND (NOT b)
@safe_call
def add_filter(self, column, lookup_type, negated, db_type, value):
# TODO: implement this or the add_filters() function (see the base
# class for a sample implementation)
# Emulated/converted lookups
if column == self.query.get_meta().pk.column:
column = '_id'
# Special-case IN
if lookup_type == 'in':
if negated:
# XXX needs testing, error for now.
raise NotImplementedError
#op = '!='
else:
op = '='
# boto needs IN queries' values to be lists of lists.
db_value = [[self.convert_value_for_db(db_type, v)] for v in value]
else:
if negated:
try:
op = NEGATION_MAP[lookup_type]
except KeyError:
raise DatabaseError("Lookup type %r can't be negated" % lookup_type)
else:
try:
op = OPERATORS_MAP[lookup_type]
except KeyError:
raise DatabaseError("Lookup type %r isn't supported" % lookup_type)
# Handle special-case lookup types
if callable(op):
op, value = op(lookup_type, value)
db_value = self.convert_value_for_db(db_type, value)
# XXX check this is right
self.db_query.filter('%s %s' % (column, op), db_value)
class BackendQuery(NonrelQuery):
def __init__(self, compiler, fields):
super(BackendQuery, self).__init__(compiler, fields)
# TODO: add your initialization code here
domain = domain_for_model(self.query.model)
self.db_query = SimpleDBQuery(self.connection.create_manager(domain),
self.query.model)
# This is needed for debugging
def __repr__(self):
# TODO: add some meaningful query string for debugging
return '<BackendQuery: %s>' % self.query.model._meta.db_table
@safe_call
def fetch(self, low_mark=None, high_mark=None):
reslice = 0
if high_mark > AWS_MAX_RESULT_SIZE:
logger.warn('Requested result size %s, assuming infinite' %
(high_mark))
reslice = high_mark
high_mark = None
# TODO: run your low-level query here
#low_mark, high_mark = self.limits
if high_mark is None:
# Infinite fetching
results = self.db_query.fetch_infinite(offset=low_mark)
if reslice:
results = list(results)[:reslice]
elif high_mark > low_mark:
# Range fetching
results = self.db_query.fetch_range(high_mark - low_mark, low_mark)
else:
results = ()
for entity in results:
entity[self.query.get_meta().pk.column] = entity['_id']
del entity['_id']
yield entity
@safe_call
def count(self, limit=None):
# TODO: implement this
return self.db_query.count(limit)
@safe_call
def delete(self):
self.db_query.delete()
@safe_call
def order_by(self, ordering):
# TODO: implement this
for order in ordering:
if order.startswith('-'):
column, direction = order[1:], 'DESC'
else:
column, direction = order, 'ASC'
if column == self.query.get_meta().pk.column:
column = '_id'
self.db_query.add_ordering(column, direction)
# This function is used by the default add_filters() implementation which
# only supports ANDed filter rules and simple negation handling for
# transforming OR filters to AND filters:
# NOT (a OR b) => (NOT a) AND (NOT b)
@safe_call
def add_filter(self, column, lookup_type, negated, db_type, value):
# TODO: implement this or the add_filters() function (see the base
# class for a sample implementation)
# Emulated/converted lookups
if column == self.query.get_meta().pk.column:
column = '_id'
# Special-case IN
if lookup_type == 'in':
if negated:
# XXX needs testing, error for now.
raise NotImplementedError
#op = '!='
else:
op = '='
# boto needs IN queries' values to be lists of lists.
db_value = [[self.convert_value_for_db(db_type, v)] for v in value]
else:
if negated:
try:
op = NEGATION_MAP[lookup_type]
except KeyError:
raise DatabaseError("Lookup type %r can't be negated" %
lookup_type)
else:
try:
op = OPERATORS_MAP[lookup_type]
except KeyError:
raise DatabaseError("Lookup type %r isn't supported" %
lookup_type)
# Handle special-case lookup types
if callable(op):
op, value = op(lookup_type, value)
db_value = self.convert_value_for_db(db_type, value)
# XXX check this is right
self.db_query.filter('%s %s' % (column, op), db_value)
