Exemple #1
0
    def test_q_with_blank_or3(self):
        q = Q() | Q(id__gt=5)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(CharFields, CharFields._meta.table())
        )

        self.assertEqual(r.where_criterion.get_sql(), '"id">5')
Exemple #2
0
    async def test_filter_not_with_or(self):
        await Tournament.create(name="0")
        await Tournament.create(name="1")
        await Tournament.create(name="2")

        tournaments = await Tournament.filter(Q(name="1") | ~Q(name="2"))
        self.assertEqual(len(tournaments), 2)
        self.assertSetEqual({t.name for t in tournaments}, {"0", "1"})
Exemple #3
0
    def test_q_complex_int3(self):
        q = Q(Q(id__lt=5, id__gt=50, join_type="OR"), join_type="AND", intnum=80)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(IntFields, IntFields._meta.table())
        )

        self.assertEqual(r.where_criterion.get_sql(), '"intnum"=80 AND ("id"<5 OR "id">50)')
Exemple #4
0
    def test_q_complex_char3(self):
        q = Q(~Q(char__lt=5, char__gt=50, join_type="OR"), join_type="AND", char_null=80)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(CharFields, CharFields._meta.table())
        )

        self.assertEqual(
            r.where_criterion.get_sql(),
            "\"char_null\"='80' AND NOT (\"char\"<'5' OR \"char\">'50')",
        )
Exemple #5
0
    async def test_filter_by_aggregation_field_with_or_not_reversed(self):
        tournament = await Tournament.create(name="0")
        await Tournament.create(name="1")
        await Tournament.create(name="2")
        await Event.create(name="1", tournament=tournament)

        tournaments = await Tournament.annotate(
            events_count=Count("events")
        ).filter(~(Q(name="2") | Q(events_count=1)))
        self.assertEqual(len(tournaments), 1)
        self.assertSetEqual({t.name for t in tournaments}, {"1"})
Exemple #6
0
    async def test_filter_by_aggregation_field_with_and_as_two_nodes(self):
        tournament = await Tournament.create(name="0")
        tournament_second = await Tournament.create(name="1")
        await Event.create(name="1", tournament=tournament)
        await Event.create(name="2", tournament=tournament_second)

        tournaments = await Tournament.annotate(
            events_count=Count("events")
        ).filter(Q(events_count=1) & Q(name="0"))
        self.assertEqual(len(tournaments), 1)
        self.assertEqual(tournaments[0].id, tournament.id)
Exemple #7
0
    async def test_filtering(self):
        tournament = Tournament(name="Tournament")
        await tournament.save()

        second_tournament = Tournament(name="Tournament 2")
        await second_tournament.save()

        event_first = Event(name="1", tournament=tournament)
        await event_first.save()
        event_second = Event(name="2", tournament=second_tournament)
        await event_second.save()
        event_third = Event(name="3", tournament=tournament)
        await event_third.save()
        event_forth = Event(name="4", tournament=second_tournament)
        await event_forth.save()

        team_first = Team(name="First")
        await team_first.save()
        team_second = Team(name="Second")
        await team_second.save()

        await team_first.events.add(event_first)
        await event_second.participants.add(team_second)

        found_events = (await Event.filter(
            Q(id__in=[event_first.id, event_second.id])
            | Q(name="3")).filter(participants__not=team_second.id
                                  ).order_by("name",
                                             "tournament_id").distinct())
        self.assertEqual(len(found_events), 2)
        self.assertEqual(found_events[0].id, event_first.id)
        self.assertEqual(found_events[1].id, event_third.id)
        await Team.filter(events__tournament_id=tournament.id
                          ).order_by("-events__name")
        await Tournament.filter(events__name__in=["1", "3"]).distinct()

        teams = await Team.filter(name__icontains="CON")
        self.assertEqual(len(teams), 1)
        self.assertEqual(teams[0].name, "Second")

        teams = await Team.filter(name__iexact="SeCoNd")
        self.assertEqual(len(teams), 1)
        self.assertEqual(teams[0].name, "Second")

        tournaments = await Tournament.filter(
            events__participants__name__startswith="Fir")
        self.assertEqual(len(tournaments), 1)
        self.assertEqual(tournaments[0], tournament)
Exemple #8
0
    def test_q_compound_and(self):
        q1 = Q(moo="cow")
        q2 = Q(moo="bull")
        q = q1 & q2

        self.assertEqual(q1.children, ())
        self.assertEqual(q1.filters, {"moo": "cow"})
        self.assertEqual(q1.join_type, Q.AND)

        self.assertEqual(q2.children, ())
        self.assertEqual(q2.filters, {"moo": "bull"})
        self.assertEqual(q2.join_type, Q.AND)

        self.assertEqual(q.children, (q1, q2))
        self.assertEqual(q.filters, {})
        self.assertEqual(q.join_type, Q.AND)
Exemple #9
0
    async def test_filter_not(self):
        await Tournament.create(name="0")
        await Tournament.create(name="1")

        tournaments = await Tournament.filter(~Q(name="1"))
        self.assertEqual(len(tournaments), 1)
        self.assertEqual(tournaments[0].name, "0")
Exemple #10
0
    def test_q_multiple_or2(self):
        q = Q(join_type="OR", id=8, intnum=80)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(IntFields, IntFields._meta.table())
        )

        self.assertEqual(r.where_criterion.get_sql(), '"id"=8 OR "intnum"=80')
Exemple #11
0
    def test_q_basic_or(self):
        q = Q(join_type="OR", id=8)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(IntFields, IntFields._meta.table())
        )

        self.assertEqual(r.where_criterion.get_sql(), '"id"=8')
Exemple #12
0
    async def test_q_object_related_query(self):
        tournament_first = await Tournament.create(name="0")
        tournament_second = await Tournament.create(name="1")
        event = await Event.create(name="1", tournament=tournament_second)
        await Event.create(name="1", tournament=tournament_first)

        fetched_event = await Event.filter(tournament=tournament_second
                                           ).first()
        self.assertEqual(fetched_event.id, event.id)

        fetched_event = await Event.filter(Q(tournament=tournament_second)
                                           ).first()
        self.assertEqual(fetched_event.id, event.id)

        fetched_event = await Event.filter(Q(tournament=tournament_second.id)
                                           ).first()
        self.assertEqual(fetched_event.id, event.id)
Exemple #13
0
    def test_q_multiple_and(self):
        q = Q(join_type="AND", id__gt=8, id__lt=10)
        r = q._resolve(
            TestQCall.DummyQuerySet(),
            QueryContext(QueryBuilder()).push(IntFields, IntFields._meta.table())
        )

        self.assertEqual(r.where_criterion.get_sql(), '"id">8 AND "id"<10')
Exemple #14
0
async def run():
    Tortoise.init(db_url="sqlite://:memory:", modules={"models": ["__main__"]})

    await Tortoise.open_connections()
    await Tortoise.generate_schemas()

    tournament = Tournament(name="Tournament")
    await tournament.save()

    second_tournament = Tournament(name="Tournament 2")
    await second_tournament.save()

    event_first = Event(name="1", tournament=tournament)
    await event_first.save()
    event_second = await Event.create(name="2", tournament=second_tournament)
    await Event.create(name="3", tournament=tournament)
    await Event.create(name="4", tournament=second_tournament)

    await Event.filter(tournament=tournament)

    team_first = Team(name="First")
    await team_first.save()
    team_second = Team(name="Second")
    await team_second.save()

    await team_first.events.add(event_first)
    await event_second.participants.add(team_second)

    print(
        await Event.filter(Q(id__in=[event_first.id, event_second.id]) | Q(name="3"))
        .filter(participants__not=team_second.id)
        .order_by("tournament__id")
        .distinct()
    )

    print(await Team.filter(events__tournament_id=tournament.id).order_by("-events__name"))
    print(
        await Tournament.filter(events__name__in=["1", "3"])
        .order_by("-events__participants__name")
        .distinct()
    )

    print(await Team.filter(name__icontains="CON"))

    print(await Tournament.filter(events__participants__name__startswith="Fir"))
    print(await Tournament.filter(id__icontains=1).count())
Exemple #15
0
    def _filter_or_exclude(self, *args, negate: bool, **kwargs):
        queryset = self._clone()
        for arg in args:
            if not isinstance(arg, Q):
                raise TypeError("expected Q objects as args")
            if negate:
                queryset.q_objects.append(~arg)
            else:
                queryset.q_objects.append(arg)

        for key, value in kwargs.items():
            if negate:
                queryset.q_objects.append(~Q(**{key: value}))
            else:
                queryset.q_objects.append(Q(**{key: value}))

        return queryset
Exemple #16
0
    async def test_q_object_backward_related_query(self):
        await Tournament.create(name="0")
        tournament = await Tournament.create(name="Tournament")
        event = await Event.create(name="1", tournament=tournament)
        fetched_tournament = await Tournament.filter(events=event.id).first()
        self.assertEqual(fetched_tournament.id, tournament.id)

        fetched_tournament = await Tournament.filter(Q(events=event.id)
                                                     ).first()
        self.assertEqual(fetched_tournament.id, tournament.id)
Exemple #17
0
    async def test_filter_by_aggregation_field_with_or_as_one_node(self):
        tournament = await Tournament.create(name="0")
        await Tournament.create(name="1")
        await Tournament.create(name="2")
        await Event.create(name="1", tournament=tournament)

        tournaments = await Tournament.annotate(events_count=Count("events")
                                                ).filter(
                                                    Q(events_count=1,
                                                      name="2",
                                                      join_type=Q.OR))
        self.assertEqual(len(tournaments), 2)
        self.assertSetEqual({t.name for t in tournaments}, {"0", "2"})
Exemple #18
0
 def __resolve_filters(self, context: QueryContext) -> None:
     Q(*self.q_objects).resolve_into(self, context)
Exemple #19
0
 def test_q_partial_or(self):
     q = Q(join_type="OR", moo="cow")
     self.assertEqual(q.children, ())
     self.assertEqual(q.filters, {"moo": "cow"})
     self.assertEqual(q.join_type, Q.OR)
Exemple #20
0
 def test_q_bad_join_type(self):
     with self.assertRaisesRegex(OperationalError, "join_type must be AND or OR"):
         Q(join_type=3)
Exemple #21
0
 def test_q_notq(self):
     with self.assertRaisesRegex(OperationalError, "All ordered arguments must be Q nodes"):
         Q(Q(), 1)
Exemple #22
0
 def test_q_compound_and_notq(self):
     with self.assertRaisesRegex(OperationalError, "AND operation requires a Q node"):
         Q() & 2  # pylint: disable=W0106
Exemple #23
0
 def test_q_basic(self):
     q = Q(moo="cow")
     self.assertEqual(q.children, ())
     self.assertEqual(q.filters, {"moo": "cow"})
     self.assertEqual(q.join_type, Q.AND)