def filter(self, *arguments, **kwargs):
'''
Filters a queryset in order to produce a different set of document from subsequent queries.
Usage::
users = await User.objects.filter(first_name="Bernardo").filter(last_name="Bernardo").find_all()
# or
users = await User.objects.filter(first_name="Bernardo", starting_year__gt=2010).find_all()
The available filter options are the same as used in MongoEngine.
'''
from aiomotorengine.query_builder.node import Q, QCombination, QNot
from aiomotorengine.query_builder.transform import validate_fields
if (arguments and len(arguments) == 1
and isinstance(arguments[0], (Q, QNot, QCombination))):
if self._filters:
self._filters = self._filters & arguments[0]
else:
self._filters = arguments[0]
else:
validate_fields(self.__klass__, kwargs)
if self._filters:
self._filters = self._filters & Q(**kwargs)
else:
if (arguments and len(arguments) == 1
and isinstance(arguments[0], dict)):
self._filters = Q(arguments[0])
else:
self._filters = Q(**kwargs)
return self
def test_gets_proper_query_when_and(self):
query = Q(embedded__test__lte="Test") & Q(first_name="Someone")
query_result = query.to_query(User)
expect(query_result).to_be_like({
"embedded_document.other": {
"$lte": "Test"
},
"whatever": "Someone"
})
def test_gets_proper_query_when_or(self):
query = Q(first_name="Someone") | Q(first_name="Else")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{'$or': [{
'whatever': 'Someone'
}, {
'whatever': 'Else'
}]})
async def test_can_query_using_not_in_with_real_users(self):
await self.create_test_users()
names = ["Someone", "John"]
query = ~Q(first_name__in=names) & Q(last_name="Heynemann")
users = await User.objects.filter(query).find_all()
expect(users).to_length(1)
expect(users[0].first_name).to_equal("Bernardo")
async def test_can_query_using_q_with_is_null(self):
await self.create_test_users()
users = await User.objects.filter(Q(nullable__is_null=True)).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(self.user._id)
users = await User.objects.filter(Q(nullable__is_null=False)
).find_all()
expect(users).to_length(2)
expect(users[0]._id).to_equal(self.user2._id)
expect(users[1]._id).to_equal(self.user3._id)
async def test_can_query_using_q(self):
await self.create_test_users()
users = await User.objects.find_all()
expect(users).to_length(3)
users = await User.objects.filter(Q(first_name="Bernardo")).find_all()
expect(users).to_length(1)
users = await User.objects.filter(
Q(first_name="Bernardo") | Q(first_name="Someone")).find_all()
expect(users).to_length(2)
def test_gets_proper_query_when_many_operators(self):
query = (Q(embedded__test__lte="Test")
& Q(first_name="Someone")) | Q(first_name="Else")
query_result = query.to_query(User)
expect(query_result).to_be_like({
'$or': [{
'embedded_document.other': {
'$lte': 'Test'
},
'whatever': 'Someone'
}, {
'whatever': 'Else'
}]
})
def filter_not(self, *arguments, **kwargs):
'''
Filters a queryset to negate all the filters passed in subsequent queries.
Usage::
objects = User.objects.filter_not(first_name="Bernardo")
objects = objects.filter_not(last_name="Bernardo")
users = await objects.find_all()
# or
objects = User.objects.filter_not(
first_name="Bernardo", starting_year__gt=2010
)
users = await objects.find_all()
The available filter options are the same as used in MongoEngine.
'''
from aiomotorengine.query_builder.node import Q, QCombination, QNot
if arguments and len(arguments) == 1 and isinstance(
arguments[0], (Q, QCombination)):
self._filters = QNot(arguments[0])
else:
self._filters = QNot(Q(**kwargs))
return self
def get(self, id=None, alias=None, **kwargs):
'''
Gets a single item of the current queryset collection using it's id.
In order to query a different database, please specify the `alias` of the database to query.
'''
from aiomotorengine import Q
if id is None and not kwargs:
raise RuntimeError(
"Either an id or a filter must be provided to get")
if id is not None:
if not isinstance(id, ObjectId):
id = ObjectId(id)
filters = {"_id": id}
else:
filters = Q(**kwargs)
filters = self.get_query_from_filters(filters)
instance = yield from self.coll(alias).find_one(filters)
if instance is None:
return None
else:
doc = self.__klass__.from_son(instance)
if self.is_lazy:
return doc
else:
yield from doc.load_references()
return doc
def test_gets_proper_query_when_embedded_document_in_many_levels(self):
query = Q(embedded__embedded2__test__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{"embedded_document.embedded2.else": {
"$lte": "Test"
}})
def test_gets_proper_query_when_embedded_document(self):
query = Q(embedded__test__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like(
{"embedded_document.other": {
"$lte": "Test"
}})
def to_query(self):
from aiomotorengine import Q
match_obj = {'$match': {}}
query = self.aggregation.queryset.get_query_from_filters(Q(**self.filters))
update(match_obj['$match'], query)
return match_obj
def test_can_query_using_not_in(self):
names = ["Someone", "John"]
query = ~Q(first_name__in=names)
query_result = query.to_query(User)
expect(query_result).to_be_like(
{'whatever': {
'$not': {
'$in': ['Someone', 'John']
}
}})
async def test_can_query_using_q_for_list(self):
await User.objects.create(email="*****@*****.**",
first_name="Bernardo",
last_name="Heynemann",
embedded=EmbeddedDocument(test="test"),
numbers=[1, 2, 3])
user2 = await User.objects.create(
email="*****@*****.**",
first_name="Someone",
last_name="Else",
embedded=EmbeddedDocument(test="test2"),
numbers=[4, 5, 6])
await User.objects.create(email="*****@*****.**",
first_name="John",
last_name="Doe",
embedded=EmbeddedDocument(test="test3"),
numbers=[7, 8, 9])
users = await User.objects.filter(Q(numbers=[4])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = await User.objects.filter(Q(numbers=[5])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = await User.objects.filter(Q(numbers=[6])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = await User.objects.filter(Q(numbers=[4, 5, 6])).find_all()
expect(users).to_length(1)
expect(users[0]._id).to_equal(user2._id)
users = await User.objects.filter(Q(numbers=[20])).find_all()
expect(users).to_length(0)
def test_gets_proper_query_when_list_field(self):
query = Q(numbers=[10])
query_result = query.to_query(User)
expect(query_result).to_be_like({"numbers": {"$all": [10]}})
def test_gets_proper_query_when_query_operator_used(self):
query = Q(first_name__lte="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like({"whatever": {"$lte": "Test"}})
def test_gets_proper_query(self):
query = Q(first_name="Test")
query_result = query.to_query(User)
expect(query_result).to_be_like({"whatever": "Test"})
def test_gets_proper_type(self):
query = Q(first_name="Test")
expect(query).to_be_instance_of(Q)
query = Q(first_name="Test") | Q(first_name="Else")
expect(query).to_be_instance_of(QCombination)
