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)