Debian Codegraph @

django/db/models/fields/tuple_lookups.py

raw
1 import itertools
2
3 from django.core.exceptions import EmptyResultSet
4 from django.db import models
5 from django.db.models.expressions import (
6 ColPairs,
7 Exists,
8 Func,
9 ResolvedOuterRef,
10 Subquery,
11 Value,
12 )
13 from django.db.models.lookups import (
14 Exact,
15 GreaterThan,
16 GreaterThanOrEqual,
17 In,
18 IsNull,
19 LessThan,
20 LessThanOrEqual,
21 )
22 from django.db.models.sql import Query
23 from django.db.models.sql.where import AND, OR, WhereNode
24
25
26 class Tuple(Func):
27 allows_composite_expressions = True
28 function = ""
29 output_field = models.Field()
30
31 def __len__(self):
32 return len(self.source_expressions)
33
34 def __iter__(self):
35 return iter(self.source_expressions)
36
37
38 class TupleLookupMixin:
39 allows_composite_expressions = True
40
41 def get_prep_lookup(self):
42 if self.rhs_is_direct_value():
43 self.check_rhs_is_tuple_or_list()
44 self.check_rhs_length_equals_lhs_length()
45 else:
46 self.check_rhs_is_supported_expression()
47 super().get_prep_lookup()
48 return self.rhs
49
50 def check_rhs_is_tuple_or_list(self):
51 if not isinstance(self.rhs, (tuple, list)):
52 lhs_str = self.get_lhs_str()
53 raise ValueError(
54 f"{self.lookup_name!r} lookup of {lhs_str} must be a tuple or a list"
55 )
56
57 def check_rhs_length_equals_lhs_length(self):
58 len_lhs = len(self.lhs)
59 if len_lhs != len(self.rhs):
60 lhs_str = self.get_lhs_str()
61 raise ValueError(
62 f"{self.lookup_name!r} lookup of {lhs_str} must have {len_lhs} elements"
63 )
64
65 def check_rhs_is_supported_expression(self):
66 if not isinstance(self.rhs, (ResolvedOuterRef, Query)):
67 lhs_str = self.get_lhs_str()
68 rhs_cls = self.rhs.__class__.__name__
69 raise ValueError(
70 f"{self.lookup_name!r} subquery lookup of {lhs_str} "
71 f"only supports OuterRef and QuerySet objects (received {rhs_cls!r})"
72 )
73
74 def get_lhs_str(self):
75 if isinstance(self.lhs, ColPairs):
76 return repr(self.lhs.field.name)
77 else:
78 names = ", ".join(repr(f.name) for f in self.lhs)
79 return f"({names})"
80
81 def get_prep_lhs(self):
82 if isinstance(self.lhs, (tuple, list)):
83 return Tuple(*self.lhs)
84 return super().get_prep_lhs()
85
86 def process_lhs(self, compiler, connection, lhs=None):
87 sql, params = super().process_lhs(compiler, connection, lhs)
88 if not isinstance(self.lhs, Tuple):
89 sql = f"({sql})"
90 return sql, params
91
92 def process_rhs(self, compiler, connection):
93 if self.rhs_is_direct_value():
94 args = [
95 (
96 val
97 if hasattr(val, "as_sql")
98 else Value(val, output_field=col.output_field)
99 )
100 for col, val in zip(self.lhs, self.rhs)
101 ]
102 return compiler.compile(Tuple(*args))
103 else:
104 sql, params = compiler.compile(self.rhs)
105 if isinstance(self.rhs, ColPairs):
106 return "(%s)" % sql, params
107 elif isinstance(self.rhs, Query):
108 return super().process_rhs(compiler, connection)
109 else:
110 raise ValueError(
111 "Composite field lookups only work with composite expressions."
112 )
113
114 def get_fallback_sql(self, compiler, connection):
115 raise NotImplementedError(
116 f"{self.__class__.__name__}.get_fallback_sql() must be implemented "
117 f"for backends that don't have the supports_tuple_lookups feature enabled."
118 )
119
120 def as_sql(self, compiler, connection):
121 if not connection.features.supports_tuple_lookups:
122 return self.get_fallback_sql(compiler, connection)
123 return super().as_sql(compiler, connection)
124
125
126 class TupleExact(TupleLookupMixin, Exact):
127 def get_fallback_sql(self, compiler, connection):
128 if isinstance(self.rhs, Query):
129 return super(TupleLookupMixin, self).as_sql(compiler, connection)
130 # Process right-hand-side to trigger sanitization.
131 self.process_rhs(compiler, connection)
132 # e.g.: (a, b, c) == (x, y, z) as SQL:
133 # WHERE a = x AND b = y AND c = z
134 lookups = [Exact(col, val) for col, val in zip(self.lhs, self.rhs)]
135 root = WhereNode(lookups, connector=AND)
136
137 return root.as_sql(compiler, connection)
138
139
140 class TupleIsNull(TupleLookupMixin, IsNull):
141 def get_prep_lookup(self):
142 rhs = self.rhs
143 if isinstance(rhs, (tuple, list)) and len(rhs) == 1:
144 rhs = rhs[0]
145 if isinstance(rhs, bool):
146 return rhs
147 raise ValueError(
148 "The QuerySet value for an isnull lookup must be True or False."
149 )
150
151 def as_sql(self, compiler, connection):
152 # e.g.: (a, b, c) is None as SQL:
153 # WHERE a IS NULL OR b IS NULL OR c IS NULL
154 # e.g.: (a, b, c) is not None as SQL:
155 # WHERE a IS NOT NULL AND b IS NOT NULL AND c IS NOT NULL
156 rhs = self.rhs
157 lookups = [IsNull(col, rhs) for col in self.lhs]
158 root = WhereNode(lookups, connector=OR if rhs else AND)
159 return root.as_sql(compiler, connection)
160
161
162 class TupleGreaterThan(TupleLookupMixin, GreaterThan):
163 def get_fallback_sql(self, compiler, connection):
164 # Process right-hand-side to trigger sanitization.
165 self.process_rhs(compiler, connection)
166 # e.g.: (a, b, c) > (x, y, z) as SQL:
167 # WHERE a > x OR (a = x AND (b > y OR (b = y AND c > z)))
168 lookups = itertools.cycle([GreaterThan, Exact])
169 connectors = itertools.cycle([OR, AND])
170 cols_list = [col for col in self.lhs for _ in range(2)]
171 vals_list = [val for val in self.rhs for _ in range(2)]
172 cols_iter = iter(cols_list[:-1])
173 vals_iter = iter(vals_list[:-1])
174 col = next(cols_iter)
175 val = next(vals_iter)
176 lookup = next(lookups)
177 connector = next(connectors)
178 root = node = WhereNode([lookup(col, val)], connector=connector)
179
180 for col, val in zip(cols_iter, vals_iter):
181 lookup = next(lookups)
182 connector = next(connectors)
183 child = WhereNode([lookup(col, val)], connector=connector)
184 node.children.append(child)
185 node = child
186
187 return root.as_sql(compiler, connection)
188
189
190 class TupleGreaterThanOrEqual(TupleLookupMixin, GreaterThanOrEqual):
191 def get_fallback_sql(self, compiler, connection):
192 # Process right-hand-side to trigger sanitization.
193 self.process_rhs(compiler, connection)
194 # e.g.: (a, b, c) >= (x, y, z) as SQL:
195 # WHERE a > x OR (a = x AND (b > y OR (b = y AND (c > z OR c = z))))
196 lookups = itertools.cycle([GreaterThan, Exact])
197 connectors = itertools.cycle([OR, AND])
198 cols_list = [col for col in self.lhs for _ in range(2)]
199 vals_list = [val for val in self.rhs for _ in range(2)]
200 cols_iter = iter(cols_list)
201 vals_iter = iter(vals_list)
202 col = next(cols_iter)
203 val = next(vals_iter)
204 lookup = next(lookups)
205 connector = next(connectors)
206 root = node = WhereNode([lookup(col, val)], connector=connector)
207
208 for col, val in zip(cols_iter, vals_iter):
209 lookup = next(lookups)
210 connector = next(connectors)
211 child = WhereNode([lookup(col, val)], connector=connector)
212 node.children.append(child)
213 node = child
214
215 return root.as_sql(compiler, connection)
216
217
218 class TupleLessThan(TupleLookupMixin, LessThan):
219 def get_fallback_sql(self, compiler, connection):
220 # Process right-hand-side to trigger sanitization.
221 self.process_rhs(compiler, connection)
222 # e.g.: (a, b, c) < (x, y, z) as SQL:
223 # WHERE a < x OR (a = x AND (b < y OR (b = y AND c < z)))
224 lookups = itertools.cycle([LessThan, Exact])
225 connectors = itertools.cycle([OR, AND])
226 cols_list = [col for col in self.lhs for _ in range(2)]
227 vals_list = [val for val in self.rhs for _ in range(2)]
228 cols_iter = iter(cols_list[:-1])
229 vals_iter = iter(vals_list[:-1])
230 col = next(cols_iter)
231 val = next(vals_iter)
232 lookup = next(lookups)
233 connector = next(connectors)
234 root = node = WhereNode([lookup(col, val)], connector=connector)
235
236 for col, val in zip(cols_iter, vals_iter):
237 lookup = next(lookups)
238 connector = next(connectors)
239 child = WhereNode([lookup(col, val)], connector=connector)
240 node.children.append(child)
241 node = child
242
243 return root.as_sql(compiler, connection)
244
245
246 class TupleLessThanOrEqual(TupleLookupMixin, LessThanOrEqual):
247 def get_fallback_sql(self, compiler, connection):
248 # Process right-hand-side to trigger sanitization.
249 self.process_rhs(compiler, connection)
250 # e.g.: (a, b, c) <= (x, y, z) as SQL:
251 # WHERE a < x OR (a = x AND (b < y OR (b = y AND (c < z OR c = z))))
252 lookups = itertools.cycle([LessThan, Exact])
253 connectors = itertools.cycle([OR, AND])
254 cols_list = [col for col in self.lhs for _ in range(2)]
255 vals_list = [val for val in self.rhs for _ in range(2)]
256 cols_iter = iter(cols_list)
257 vals_iter = iter(vals_list)
258 col = next(cols_iter)
259 val = next(vals_iter)
260 lookup = next(lookups)
261 connector = next(connectors)
262 root = node = WhereNode([lookup(col, val)], connector=connector)
263
264 for col, val in zip(cols_iter, vals_iter):
265 lookup = next(lookups)
266 connector = next(connectors)
267 child = WhereNode([lookup(col, val)], connector=connector)
268 node.children.append(child)
269 node = child
270
271 return root.as_sql(compiler, connection)
272
273
274 class TupleIn(TupleLookupMixin, In):
275 def get_prep_lookup(self):
276 if self.rhs_is_direct_value():
277 self.check_rhs_is_tuple_or_list()
278 self.check_rhs_is_collection_of_tuples_or_lists()
279 self.check_rhs_elements_length_equals_lhs_length()
280 else:
281 self.check_rhs_is_query()
282 super(TupleLookupMixin, self).get_prep_lookup()
283
284 return self.rhs # skip checks from mixin
285
286 def check_rhs_is_collection_of_tuples_or_lists(self):
287 if not all(isinstance(vals, (tuple, list)) for vals in self.rhs):
288 lhs_str = self.get_lhs_str()
289 raise ValueError(
290 f"{self.lookup_name!r} lookup of {lhs_str} "
291 "must be a collection of tuples or lists"
292 )
293
294 def check_rhs_elements_length_equals_lhs_length(self):
295 len_lhs = len(self.lhs)
296 if not all(len_lhs == len(vals) for vals in self.rhs):
297 lhs_str = self.get_lhs_str()
298 raise ValueError(
299 f"{self.lookup_name!r} lookup of {lhs_str} "
300 f"must have {len_lhs} elements each"
301 )
302
303 def check_rhs_is_query(self):
304 if not isinstance(self.rhs, (Query, Subquery)):
305 lhs_str = self.get_lhs_str()
306 rhs_cls = self.rhs.__class__.__name__
307 raise ValueError(
308 f"{self.lookup_name!r} subquery lookup of {lhs_str} "
309 f"must be a Query object (received {rhs_cls!r})"
310 )
311
312 def process_rhs(self, compiler, connection):
313 if not self.rhs_is_direct_value():
314 return super(TupleLookupMixin, self).process_rhs(compiler, connection)
315
316 rhs = self.rhs
317 if not rhs:
318 raise EmptyResultSet
319
320 # e.g.: (a, b, c) in [(x1, y1, z1), (x2, y2, z2)] as SQL:
321 # WHERE (a, b, c) IN ((x1, y1, z1), (x2, y2, z2))
322 result = []
323 lhs = self.lhs
324
325 for vals in rhs:
326 # Remove any tuple containing None from the list as NULL is never
327 # equal to anything.
328 if any(val is None for val in vals):
329 continue
330 result.append(
331 Tuple(
332 *[
333 (
334 val
335 if hasattr(val, "as_sql")
336 else Value(val, output_field=col.output_field)
337 )
338 for col, val in zip(lhs, vals)
339 ]
340 )
341 )
342
343 if not result:
344 raise EmptyResultSet
345
346 return compiler.compile(Tuple(*result))
347
348 def get_fallback_sql(self, compiler, connection):
349 rhs = self.rhs
350 if not rhs:
351 raise EmptyResultSet
352 if isinstance(rhs, Query):
353 rhs_exprs = itertools.chain.from_iterable(
354 (
355 select_expr
356 if isinstance((select_expr := select[0]), ColPairs)
357 else [select_expr]
358 )
359 for select in rhs.get_compiler(connection=connection).get_select()[0]
360 )
361 rhs = rhs.clone()
362 rhs.add_q(
363 models.Q(*[Exact(col, val) for col, val in zip(self.lhs, rhs_exprs)])
364 )
365 return compiler.compile(Exists(rhs))
366 elif not self.rhs_is_direct_value():
367 return super(TupleLookupMixin, self).as_sql(compiler, connection)
368
369 # e.g.: (a, b, c) in [(x1, y1, z1), (x2, y2, z2)] as SQL:
370 # WHERE (a = x1 AND b = y1 AND c = z1) OR (a = x2 AND b = y2 AND c = z2)
371 root = WhereNode([], connector=OR)
372 lhs = self.lhs
373
374 for vals in rhs:
375 # Remove any tuple containing None from the list as NULL is never
376 # equal to anything.
377 if any(val is None for val in vals):
378 continue
379 lookups = [Exact(col, val) for col, val in zip(lhs, vals)]
380 root.children.append(WhereNode(lookups, connector=AND))
381
382 if not root.children:
383 raise EmptyResultSet
384 return root.as_sql(compiler, connection)
385
386
387 tuple_lookups = {
388 "exact": TupleExact,
389 "gt": TupleGreaterThan,
390 "gte": TupleGreaterThanOrEqual,
391 "lt": TupleLessThan,
392 "lte": TupleLessThanOrEqual,
393 "in": TupleIn,
394 "isnull": TupleIsNull,
395 }