| 1 |
from unittest import mock |
| 2 |
|
| 3 |
from django.conf import settings |
| 4 |
from django.db import connection, models |
| 5 |
from django.db.models.functions import Lower, Upper |
| 6 |
from django.test import SimpleTestCase, TestCase, override_settings, skipUnlessDBFeature |
| 7 |
from django.test.utils import isolate_apps |
| 8 |
|
| 9 |
from .models import Book, ChildModel1, ChildModel2 |
| 10 |
|
| 11 |
|
| 12 |
class SimpleIndexesTests(SimpleTestCase): |
| 13 |
def test_suffix(self): |
| 14 |
self.assertEqual(models.Index.suffix, "idx") |
| 15 |
|
| 16 |
def test_repr(self): |
| 17 |
index = models.Index(fields=["title"]) |
| 18 |
named_index = models.Index(fields=["title"], name="title_idx") |
| 19 |
multi_col_index = models.Index(fields=["title", "author"]) |
| 20 |
partial_index = models.Index( |
| 21 |
fields=["title"], name="long_books_idx", condition=models.Q(pages__gt=400) |
| 22 |
) |
| 23 |
covering_index = models.Index( |
| 24 |
fields=["title"], |
| 25 |
name="include_idx", |
| 26 |
include=["author", "pages"], |
| 27 |
) |
| 28 |
opclasses_index = models.Index( |
| 29 |
fields=["headline", "body"], |
| 30 |
name="opclasses_idx", |
| 31 |
opclasses=["varchar_pattern_ops", "text_pattern_ops"], |
| 32 |
) |
| 33 |
func_index = models.Index(Lower("title"), "subtitle", name="book_func_idx") |
| 34 |
tablespace_index = models.Index( |
| 35 |
fields=["title"], |
| 36 |
db_tablespace="idx_tbls", |
| 37 |
name="book_tablespace_idx", |
| 38 |
) |
| 39 |
self.assertEqual(repr(index), "<Index: fields=['title']>") |
| 40 |
self.assertEqual( |
| 41 |
repr(named_index), |
| 42 |
"<Index: fields=['title'] name='title_idx'>", |
| 43 |
) |
| 44 |
self.assertEqual(repr(multi_col_index), "<Index: fields=['title', 'author']>") |
| 45 |
self.assertEqual( |
| 46 |
repr(partial_index), |
| 47 |
"<Index: fields=['title'] name='long_books_idx' " |
| 48 |
"condition=(AND: ('pages__gt', 400))>", |
| 49 |
) |
| 50 |
self.assertEqual( |
| 51 |
repr(covering_index), |
| 52 |
"<Index: fields=['title'] name='include_idx' " |
| 53 |
"include=('author', 'pages')>", |
| 54 |
) |
| 55 |
self.assertEqual( |
| 56 |
repr(opclasses_index), |
| 57 |
"<Index: fields=['headline', 'body'] name='opclasses_idx' " |
| 58 |
"opclasses=['varchar_pattern_ops', 'text_pattern_ops']>", |
| 59 |
) |
| 60 |
self.assertEqual( |
| 61 |
repr(func_index), |
| 62 |
"<Index: expressions=(Lower(F(title)), F(subtitle)) " |
| 63 |
"name='book_func_idx'>", |
| 64 |
) |
| 65 |
self.assertEqual( |
| 66 |
repr(tablespace_index), |
| 67 |
"<Index: fields=['title'] name='book_tablespace_idx' " |
| 68 |
"db_tablespace='idx_tbls'>", |
| 69 |
) |
| 70 |
|
| 71 |
def test_eq(self): |
| 72 |
index = models.Index(fields=["title"]) |
| 73 |
same_index = models.Index(fields=["title"]) |
| 74 |
another_index = models.Index(fields=["title", "author"]) |
| 75 |
index.model = Book |
| 76 |
same_index.model = Book |
| 77 |
another_index.model = Book |
| 78 |
self.assertEqual(index, same_index) |
| 79 |
self.assertEqual(index, mock.ANY) |
| 80 |
self.assertNotEqual(index, another_index) |
| 81 |
|
| 82 |
def test_eq_func(self): |
| 83 |
index = models.Index(Lower("title"), models.F("author"), name="book_func_idx") |
| 84 |
same_index = models.Index(Lower("title"), "author", name="book_func_idx") |
| 85 |
another_index = models.Index(Lower("title"), name="book_func_idx") |
| 86 |
self.assertEqual(index, same_index) |
| 87 |
self.assertEqual(index, mock.ANY) |
| 88 |
self.assertNotEqual(index, another_index) |
| 89 |
|
| 90 |
def test_index_fields_type(self): |
| 91 |
with self.assertRaisesMessage( |
| 92 |
ValueError, "Index.fields must be a list or tuple." |
| 93 |
): |
| 94 |
models.Index(fields="title") |
| 95 |
|
| 96 |
def test_index_fields_strings(self): |
| 97 |
msg = "Index.fields must contain only strings with field names." |
| 98 |
with self.assertRaisesMessage(ValueError, msg): |
| 99 |
models.Index(fields=[models.F("title")]) |
| 100 |
|
| 101 |
def test_fields_tuple(self): |
| 102 |
self.assertEqual(models.Index(fields=("title",)).fields, ["title"]) |
| 103 |
|
| 104 |
def test_requires_field_or_expression(self): |
| 105 |
msg = "At least one field or expression is required to define an index." |
| 106 |
with self.assertRaisesMessage(ValueError, msg): |
| 107 |
models.Index() |
| 108 |
|
| 109 |
def test_expressions_and_fields_mutually_exclusive(self): |
| 110 |
msg = "Index.fields and expressions are mutually exclusive." |
| 111 |
with self.assertRaisesMessage(ValueError, msg): |
| 112 |
models.Index(Upper("foo"), fields=["field"]) |
| 113 |
|
| 114 |
def test_opclasses_requires_index_name(self): |
| 115 |
with self.assertRaisesMessage( |
| 116 |
ValueError, "An index must be named to use opclasses." |
| 117 |
): |
| 118 |
models.Index(opclasses=["jsonb_path_ops"]) |
| 119 |
|
| 120 |
def test_opclasses_requires_list_or_tuple(self): |
| 121 |
with self.assertRaisesMessage( |
| 122 |
ValueError, "Index.opclasses must be a list or tuple." |
| 123 |
): |
| 124 |
models.Index( |
| 125 |
name="test_opclass", fields=["field"], opclasses="jsonb_path_ops" |
| 126 |
) |
| 127 |
|
| 128 |
def test_opclasses_and_fields_same_length(self): |
| 129 |
msg = "Index.fields and Index.opclasses must have the same number of elements." |
| 130 |
with self.assertRaisesMessage(ValueError, msg): |
| 131 |
models.Index( |
| 132 |
name="test_opclass", |
| 133 |
fields=["field", "other"], |
| 134 |
opclasses=["jsonb_path_ops"], |
| 135 |
) |
| 136 |
|
| 137 |
def test_condition_requires_index_name(self): |
| 138 |
with self.assertRaisesMessage( |
| 139 |
ValueError, "An index must be named to use condition." |
| 140 |
): |
| 141 |
models.Index(condition=models.Q(pages__gt=400)) |
| 142 |
|
| 143 |
def test_expressions_requires_index_name(self): |
| 144 |
msg = "An index must be named to use expressions." |
| 145 |
with self.assertRaisesMessage(ValueError, msg): |
| 146 |
models.Index(Lower("field")) |
| 147 |
|
| 148 |
def test_expressions_with_opclasses(self): |
| 149 |
msg = ( |
| 150 |
"Index.opclasses cannot be used with expressions. Use " |
| 151 |
"django.contrib.postgres.indexes.OpClass() instead." |
| 152 |
) |
| 153 |
with self.assertRaisesMessage(ValueError, msg): |
| 154 |
models.Index( |
| 155 |
Lower("field"), |
| 156 |
name="test_func_opclass", |
| 157 |
opclasses=["jsonb_path_ops"], |
| 158 |
) |
| 159 |
|
| 160 |
def test_condition_must_be_q(self): |
| 161 |
with self.assertRaisesMessage( |
| 162 |
ValueError, "Index.condition must be a Q instance." |
| 163 |
): |
| 164 |
models.Index(condition="invalid", name="long_book_idx") |
| 165 |
|
| 166 |
def test_include_requires_list_or_tuple(self): |
| 167 |
msg = "Index.include must be a list or tuple." |
| 168 |
with self.assertRaisesMessage(ValueError, msg): |
| 169 |
models.Index(name="test_include", fields=["field"], include="other") |
| 170 |
|
| 171 |
def test_include_requires_index_name(self): |
| 172 |
msg = "A covering index must be named." |
| 173 |
with self.assertRaisesMessage(ValueError, msg): |
| 174 |
models.Index(fields=["field"], include=["other"]) |
| 175 |
|
| 176 |
def test_name_auto_generation(self): |
| 177 |
index = models.Index(fields=["author"]) |
| 178 |
index.set_name_with_model(Book) |
| 179 |
self.assertEqual(index.name, "model_index_author_0f5565_idx") |
| 180 |
|
| 181 |
# '-' for DESC columns should be accounted for in the index name. |
| 182 |
index = models.Index(fields=["-author"]) |
| 183 |
index.set_name_with_model(Book) |
| 184 |
self.assertEqual(index.name, "model_index_author_708765_idx") |
| 185 |
|
| 186 |
# fields may be truncated in the name. db_column is used for naming. |
| 187 |
long_field_index = models.Index(fields=["pages"]) |
| 188 |
long_field_index.set_name_with_model(Book) |
| 189 |
self.assertEqual(long_field_index.name, "model_index_page_co_69235a_idx") |
| 190 |
|
| 191 |
# suffix can't be longer than 3 characters. |
| 192 |
long_field_index.suffix = "suff" |
| 193 |
msg = ( |
| 194 |
"Index too long for multiple database support. Is self.suffix " |
| 195 |
"longer than 3 characters?" |
| 196 |
) |
| 197 |
with self.assertRaisesMessage(ValueError, msg): |
| 198 |
long_field_index.set_name_with_model(Book) |
| 199 |
|
| 200 |
@isolate_apps("model_indexes") |
| 201 |
def test_name_auto_generation_with_quoted_db_table(self): |
| 202 |
class QuotedDbTable(models.Model): |
| 203 |
name = models.CharField(max_length=50) |
| 204 |
|
| 205 |
class Meta: |
| 206 |
db_table = '"t_quoted"' |
| 207 |
|
| 208 |
index = models.Index(fields=["name"]) |
| 209 |
index.set_name_with_model(QuotedDbTable) |
| 210 |
self.assertEqual(index.name, "t_quoted_name_e4ed1b_idx") |
| 211 |
|
| 212 |
def test_deconstruction(self): |
| 213 |
index = models.Index(fields=["title"], db_tablespace="idx_tbls") |
| 214 |
index.set_name_with_model(Book) |
| 215 |
path, args, kwargs = index.deconstruct() |
| 216 |
self.assertEqual(path, "django.db.models.Index") |
| 217 |
self.assertEqual(args, ()) |
| 218 |
self.assertEqual( |
| 219 |
kwargs, |
| 220 |
{ |
| 221 |
"fields": ["title"], |
| 222 |
"name": "model_index_title_196f42_idx", |
| 223 |
"db_tablespace": "idx_tbls", |
| 224 |
}, |
| 225 |
) |
| 226 |
|
| 227 |
def test_deconstruct_with_condition(self): |
| 228 |
index = models.Index( |
| 229 |
name="big_book_index", |
| 230 |
fields=["title"], |
| 231 |
condition=models.Q(pages__gt=400), |
| 232 |
) |
| 233 |
index.set_name_with_model(Book) |
| 234 |
path, args, kwargs = index.deconstruct() |
| 235 |
self.assertEqual(path, "django.db.models.Index") |
| 236 |
self.assertEqual(args, ()) |
| 237 |
self.assertEqual( |
| 238 |
kwargs, |
| 239 |
{ |
| 240 |
"fields": ["title"], |
| 241 |
"name": "model_index_title_196f42_idx", |
| 242 |
"condition": models.Q(pages__gt=400), |
| 243 |
}, |
| 244 |
) |
| 245 |
|
| 246 |
def test_deconstruct_with_include(self): |
| 247 |
index = models.Index( |
| 248 |
name="book_include_idx", |
| 249 |
fields=["title"], |
| 250 |
include=["author"], |
| 251 |
) |
| 252 |
index.set_name_with_model(Book) |
| 253 |
path, args, kwargs = index.deconstruct() |
| 254 |
self.assertEqual(path, "django.db.models.Index") |
| 255 |
self.assertEqual(args, ()) |
| 256 |
self.assertEqual( |
| 257 |
kwargs, |
| 258 |
{ |
| 259 |
"fields": ["title"], |
| 260 |
"name": "model_index_title_196f42_idx", |
| 261 |
"include": ("author",), |
| 262 |
}, |
| 263 |
) |
| 264 |
|
| 265 |
def test_deconstruct_with_expressions(self): |
| 266 |
index = models.Index(Upper("title"), name="book_func_idx") |
| 267 |
path, args, kwargs = index.deconstruct() |
| 268 |
self.assertEqual(path, "django.db.models.Index") |
| 269 |
self.assertEqual(args, (Upper("title"),)) |
| 270 |
self.assertEqual(kwargs, {"name": "book_func_idx"}) |
| 271 |
|
| 272 |
def test_clone(self): |
| 273 |
index = models.Index(fields=["title"]) |
| 274 |
new_index = index.clone() |
| 275 |
self.assertIsNot(index, new_index) |
| 276 |
self.assertEqual(index.fields, new_index.fields) |
| 277 |
|
| 278 |
def test_clone_with_expressions(self): |
| 279 |
index = models.Index(Upper("title"), name="book_func_idx") |
| 280 |
new_index = index.clone() |
| 281 |
self.assertIsNot(index, new_index) |
| 282 |
self.assertEqual(index.expressions, new_index.expressions) |
| 283 |
|
| 284 |
def test_name_set(self): |
| 285 |
index_names = [index.name for index in Book._meta.indexes] |
| 286 |
self.assertCountEqual( |
| 287 |
index_names, |
| 288 |
[ |
| 289 |
"model_index_title_196f42_idx", |
| 290 |
"model_index_isbn_34f975_idx", |
| 291 |
"model_indexes_book_barcode_idx", |
| 292 |
], |
| 293 |
) |
| 294 |
|
| 295 |
def test_abstract_children(self): |
| 296 |
index_names = [index.name for index in ChildModel1._meta.indexes] |
| 297 |
self.assertEqual( |
| 298 |
index_names, |
| 299 |
["model_index_name_440998_idx", "model_indexes_childmodel1_idx"], |
| 300 |
) |
| 301 |
index_names = [index.name for index in ChildModel2._meta.indexes] |
| 302 |
self.assertEqual( |
| 303 |
index_names, |
| 304 |
["model_index_name_b6c374_idx", "model_indexes_childmodel2_idx"], |
| 305 |
) |
| 306 |
|
| 307 |
|
| 308 |
@override_settings(DEFAULT_TABLESPACE=None) |
| 309 |
class IndexesTests(TestCase): |
| 310 |
@skipUnlessDBFeature("supports_tablespaces") |
| 311 |
def test_db_tablespace(self): |
| 312 |
editor = connection.schema_editor() |
| 313 |
# Index with db_tablespace attribute. |
| 314 |
for fields in [ |
| 315 |
# Field with db_tablespace specified on model. |
| 316 |
["shortcut"], |
| 317 |
# Field without db_tablespace specified on model. |
| 318 |
["author"], |
| 319 |
# Multi-column with db_tablespaces specified on model. |
| 320 |
["shortcut", "isbn"], |
| 321 |
# Multi-column without db_tablespace specified on model. |
| 322 |
["title", "author"], |
| 323 |
]: |
| 324 |
with self.subTest(fields=fields): |
| 325 |
index = models.Index(fields=fields, db_tablespace="idx_tbls2") |
| 326 |
self.assertIn( |
| 327 |
'"idx_tbls2"', str(index.create_sql(Book, editor)).lower() |
| 328 |
) |
| 329 |
# Indexes without db_tablespace attribute. |
| 330 |
for fields in [["author"], ["shortcut", "isbn"], ["title", "author"]]: |
| 331 |
with self.subTest(fields=fields): |
| 332 |
index = models.Index(fields=fields) |
| 333 |
# The DEFAULT_INDEX_TABLESPACE setting can't be tested because |
| 334 |
# it's evaluated when the model class is defined. As a |
| 335 |
# consequence, @override_settings doesn't work. |
| 336 |
if settings.DEFAULT_INDEX_TABLESPACE: |
| 337 |
self.assertIn( |
| 338 |
'"%s"' % settings.DEFAULT_INDEX_TABLESPACE, |
| 339 |
str(index.create_sql(Book, editor)).lower(), |
| 340 |
) |
| 341 |
else: |
| 342 |
self.assertNotIn("TABLESPACE", str(index.create_sql(Book, editor))) |
| 343 |
# Field with db_tablespace specified on the model and an index without |
| 344 |
# db_tablespace. |
| 345 |
index = models.Index(fields=["shortcut"]) |
| 346 |
self.assertIn('"idx_tbls"', str(index.create_sql(Book, editor)).lower()) |
| 347 |
|
| 348 |
@skipUnlessDBFeature("supports_tablespaces") |
| 349 |
def test_func_with_tablespace(self): |
| 350 |
# Functional index with db_tablespace attribute. |
| 351 |
index = models.Index( |
| 352 |
Lower("shortcut").desc(), |
| 353 |
name="functional_tbls", |
| 354 |
db_tablespace="idx_tbls2", |
| 355 |
) |
| 356 |
with connection.schema_editor() as editor: |
| 357 |
sql = str(index.create_sql(Book, editor)) |
| 358 |
self.assertIn(editor.quote_name("idx_tbls2"), sql) |
| 359 |
# Functional index without db_tablespace attribute. |
| 360 |
index = models.Index(Lower("shortcut").desc(), name="functional_no_tbls") |
| 361 |
with connection.schema_editor() as editor: |
| 362 |
sql = str(index.create_sql(Book, editor)) |
| 363 |
# The DEFAULT_INDEX_TABLESPACE setting can't be tested because it's |
| 364 |
# evaluated when the model class is defined. As a consequence, |
| 365 |
# @override_settings doesn't work. |
| 366 |
if settings.DEFAULT_INDEX_TABLESPACE: |
| 367 |
self.assertIn( |
| 368 |
editor.quote_name(settings.DEFAULT_INDEX_TABLESPACE), |
| 369 |
sql, |
| 370 |
) |
| 371 |
else: |
| 372 |
self.assertNotIn("TABLESPACE", sql) |