Debian Codegraph @

tests/postgres_tests/test_trigram.py

raw
1 from django.db.models import F, Value
2 from django.db.models.functions import Concat
3
4 from . import PostgreSQLTestCase
5 from .models import CharFieldModel, TextFieldModel
6
7 try:
8 from django.contrib.postgres.search import (
9 TrigramDistance,
10 TrigramSimilarity,
11 TrigramStrictWordDistance,
12 TrigramStrictWordSimilarity,
13 TrigramWordDistance,
14 TrigramWordSimilarity,
15 )
16 except ImportError:
17 pass
18
19
20 class TrigramTest(PostgreSQLTestCase):
21 Model = CharFieldModel
22
23 @classmethod
24 def setUpTestData(cls):
25 cls.Model.objects.bulk_create(
26 [
27 cls.Model(field="Matthew"),
28 cls.Model(field="Cat sat on mat."),
29 cls.Model(field="Dog sat on rug."),
30 ]
31 )
32
33 def test_trigram_search(self):
34 self.assertQuerySetEqual(
35 self.Model.objects.filter(field__trigram_similar="Mathew"),
36 ["Matthew"],
37 transform=lambda instance: instance.field,
38 )
39
40 def test_trigram_word_search(self):
41 obj = self.Model.objects.create(
42 field="Gumby rides on the path of Middlesbrough",
43 )
44 self.assertSequenceEqual(
45 self.Model.objects.filter(field__trigram_word_similar="Middlesborough"),
46 [obj],
47 )
48 self.assertSequenceEqual(
49 self.Model.objects.filter(field__trigram_word_similar="Middle"),
50 [obj],
51 )
52
53 def test_trigram_strict_word_search_matched(self):
54 obj = self.Model.objects.create(
55 field="Gumby rides on the path of Middlesbrough",
56 )
57 self.assertSequenceEqual(
58 self.Model.objects.filter(
59 field__trigram_strict_word_similar="Middlesborough"
60 ),
61 [obj],
62 )
63 self.assertSequenceEqual(
64 self.Model.objects.filter(field__trigram_strict_word_similar="Middle"),
65 [],
66 )
67
68 def test_trigram_similarity(self):
69 search = "Bat sat on cat."
70 # Round result of similarity because PostgreSQL uses greater precision.
71 self.assertQuerySetEqual(
72 self.Model.objects.filter(
73 field__trigram_similar=search,
74 )
75 .annotate(similarity=TrigramSimilarity("field", search))
76 .order_by("-similarity"),
77 [("Cat sat on mat.", 0.625), ("Dog sat on rug.", 0.333333)],
78 transform=lambda instance: (instance.field, round(instance.similarity, 6)),
79 ordered=True,
80 )
81
82 def test_trigram_word_similarity(self):
83 search = "mat"
84 self.assertSequenceEqual(
85 self.Model.objects.filter(
86 field__trigram_word_similar=search,
87 )
88 .annotate(
89 word_similarity=TrigramWordSimilarity(search, "field"),
90 )
91 .values("field", "word_similarity")
92 .order_by("-word_similarity"),
93 [
94 {"field": "Cat sat on mat.", "word_similarity": 1.0},
95 {"field": "Matthew", "word_similarity": 0.75},
96 ],
97 )
98
99 def test_trigram_strict_word_similarity(self):
100 search = "matt"
101 self.assertSequenceEqual(
102 self.Model.objects.filter(field__trigram_word_similar=search)
103 .annotate(word_similarity=TrigramStrictWordSimilarity(search, "field"))
104 .values("field", "word_similarity")
105 .order_by("-word_similarity"),
106 [
107 {"field": "Cat sat on mat.", "word_similarity": 0.5},
108 {"field": "Matthew", "word_similarity": 0.44444445},
109 ],
110 )
111
112 def test_trigram_similarity_alternate(self):
113 # Round result of distance because PostgreSQL uses greater precision.
114 self.assertQuerySetEqual(
115 self.Model.objects.annotate(
116 distance=TrigramDistance("field", "Bat sat on cat."),
117 )
118 .filter(distance__lte=0.7)
119 .order_by("distance"),
120 [("Cat sat on mat.", 0.375), ("Dog sat on rug.", 0.666667)],
121 transform=lambda instance: (instance.field, round(instance.distance, 6)),
122 ordered=True,
123 )
124
125 def test_trigram_word_similarity_alternate(self):
126 self.assertSequenceEqual(
127 self.Model.objects.annotate(
128 word_distance=TrigramWordDistance("mat", "field"),
129 )
130 .filter(
131 word_distance__lte=0.7,
132 )
133 .values("field", "word_distance")
134 .order_by("word_distance"),
135 [
136 {"field": "Cat sat on mat.", "word_distance": 0},
137 {"field": "Matthew", "word_distance": 0.25},
138 ],
139 )
140
141 def test_trigram_strict_word_distance(self):
142 self.assertSequenceEqual(
143 self.Model.objects.annotate(
144 word_distance=TrigramStrictWordDistance("matt", "field"),
145 )
146 .filter(word_distance__lte=0.7)
147 .values("field", "word_distance")
148 .order_by("word_distance"),
149 [
150 {"field": "Cat sat on mat.", "word_distance": 0.5},
151 {"field": "Matthew", "word_distance": 0.5555556},
152 ],
153 )
154
155 def test_trigram_concat_precedence(self):
156 search_term = "im matthew"
157 self.assertSequenceEqual(
158 self.Model.objects.annotate(
159 concat_result=Concat(
160 Value("I'm "),
161 F("field"),
162 output_field=self.Model._meta.get_field("field"),
163 ),
164 )
165 .filter(concat_result__trigram_similar=search_term)
166 .values("field"),
167 [{"field": "Matthew"}],
168 )
169
170
171 class TrigramTextFieldTest(TrigramTest):
172 """
173 TextField has the same behavior as CharField regarding trigram lookups.
174 """
175
176 Model = TextFieldModel