mirror of
https://github.com/django/django.git
synced 2025-07-28 23:54:02 +00:00
Refs #33476 -- Reformatted code with Black.
This commit is contained in:
django-bot
Mariusz Felisiak
parent
f68fa8b45d
commit
9c19aff7c7
1992 changed files with 139577 additions and 96284 deletions
|
|
@ -1,7 +1,13 @@
|
|||
from unittest import mock
|
||||
|
||||
from django.contrib.postgres.indexes import (
|
||||
BloomIndex, BrinIndex, BTreeIndex, GinIndex, GistIndex, HashIndex, OpClass,
|
||||
BloomIndex,
|
||||
BrinIndex,
|
||||
BTreeIndex,
|
||||
GinIndex,
|
||||
GistIndex,
|
||||
HashIndex,
|
||||
OpClass,
|
||||
SpGistIndex,
|
||||
)
|
||||
from django.db import NotSupportedError, connection
|
||||
|
|
@ -16,191 +22,226 @@ from .models import CharFieldModel, IntegerArrayModel, Scene, TextFieldModel
|
|||
|
||||
|
||||
class IndexTestMixin:
|
||||
|
||||
def test_name_auto_generation(self):
|
||||
index = self.index_class(fields=['field'])
|
||||
index = self.index_class(fields=["field"])
|
||||
index.set_name_with_model(CharFieldModel)
|
||||
self.assertRegex(index.name, r'postgres_te_field_[0-9a-f]{6}_%s' % self.index_class.suffix)
|
||||
self.assertRegex(
|
||||
index.name, r"postgres_te_field_[0-9a-f]{6}_%s" % self.index_class.suffix
|
||||
)
|
||||
|
||||
def test_deconstruction_no_customization(self):
|
||||
index = self.index_class(fields=['title'], name='test_title_%s' % self.index_class.suffix)
|
||||
index = self.index_class(
|
||||
fields=["title"], name="test_title_%s" % self.index_class.suffix
|
||||
)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.%s' % self.index_class.__name__)
|
||||
self.assertEqual(
|
||||
path, "django.contrib.postgres.indexes.%s" % self.index_class.__name__
|
||||
)
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {'fields': ['title'], 'name': 'test_title_%s' % self.index_class.suffix})
|
||||
self.assertEqual(
|
||||
kwargs,
|
||||
{"fields": ["title"], "name": "test_title_%s" % self.index_class.suffix},
|
||||
)
|
||||
|
||||
def test_deconstruction_with_expressions_no_customization(self):
|
||||
name = f'test_title_{self.index_class.suffix}'
|
||||
index = self.index_class(Lower('title'), name=name)
|
||||
name = f"test_title_{self.index_class.suffix}"
|
||||
index = self.index_class(Lower("title"), name=name)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(
|
||||
path,
|
||||
f'django.contrib.postgres.indexes.{self.index_class.__name__}',
|
||||
f"django.contrib.postgres.indexes.{self.index_class.__name__}",
|
||||
)
|
||||
self.assertEqual(args, (Lower('title'),))
|
||||
self.assertEqual(kwargs, {'name': name})
|
||||
self.assertEqual(args, (Lower("title"),))
|
||||
self.assertEqual(kwargs, {"name": name})
|
||||
|
||||
|
||||
class BloomIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = BloomIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(BloomIndex.suffix, 'bloom')
|
||||
self.assertEqual(BloomIndex.suffix, "bloom")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = BloomIndex(fields=['title'], name='test_bloom', length=80, columns=[4])
|
||||
index = BloomIndex(fields=["title"], name="test_bloom", length=80, columns=[4])
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.BloomIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.BloomIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {
|
||||
'fields': ['title'],
|
||||
'name': 'test_bloom',
|
||||
'length': 80,
|
||||
'columns': [4],
|
||||
})
|
||||
self.assertEqual(
|
||||
kwargs,
|
||||
{
|
||||
"fields": ["title"],
|
||||
"name": "test_bloom",
|
||||
"length": 80,
|
||||
"columns": [4],
|
||||
},
|
||||
)
|
||||
|
||||
def test_invalid_fields(self):
|
||||
msg = 'Bloom indexes support a maximum of 32 fields.'
|
||||
msg = "Bloom indexes support a maximum of 32 fields."
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
BloomIndex(fields=['title'] * 33, name='test_bloom')
|
||||
BloomIndex(fields=["title"] * 33, name="test_bloom")
|
||||
|
||||
def test_invalid_columns(self):
|
||||
msg = 'BloomIndex.columns must be a list or tuple.'
|
||||
msg = "BloomIndex.columns must be a list or tuple."
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
BloomIndex(fields=['title'], name='test_bloom', columns='x')
|
||||
msg = 'BloomIndex.columns cannot have more values than fields.'
|
||||
BloomIndex(fields=["title"], name="test_bloom", columns="x")
|
||||
msg = "BloomIndex.columns cannot have more values than fields."
|
||||
with self.assertRaisesMessage(ValueError, msg):
|
||||
BloomIndex(fields=['title'], name='test_bloom', columns=[4, 3])
|
||||
BloomIndex(fields=["title"], name="test_bloom", columns=[4, 3])
|
||||
|
||||
def test_invalid_columns_value(self):
|
||||
msg = 'BloomIndex.columns must contain integers from 1 to 4095.'
|
||||
msg = "BloomIndex.columns must contain integers from 1 to 4095."
|
||||
for length in (0, 4096):
|
||||
with self.subTest(length), self.assertRaisesMessage(ValueError, msg):
|
||||
BloomIndex(fields=['title'], name='test_bloom', columns=[length])
|
||||
BloomIndex(fields=["title"], name="test_bloom", columns=[length])
|
||||
|
||||
def test_invalid_length(self):
|
||||
msg = 'BloomIndex.length must be None or an integer from 1 to 4096.'
|
||||
msg = "BloomIndex.length must be None or an integer from 1 to 4096."
|
||||
for length in (0, 4097):
|
||||
with self.subTest(length), self.assertRaisesMessage(ValueError, msg):
|
||||
BloomIndex(fields=['title'], name='test_bloom', length=length)
|
||||
BloomIndex(fields=["title"], name="test_bloom", length=length)
|
||||
|
||||
|
||||
class BrinIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = BrinIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(BrinIndex.suffix, 'brin')
|
||||
self.assertEqual(BrinIndex.suffix, "brin")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = BrinIndex(fields=['title'], name='test_title_brin', autosummarize=True, pages_per_range=16)
|
||||
index = BrinIndex(
|
||||
fields=["title"],
|
||||
name="test_title_brin",
|
||||
autosummarize=True,
|
||||
pages_per_range=16,
|
||||
)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.BrinIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.BrinIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {
|
||||
'fields': ['title'],
|
||||
'name': 'test_title_brin',
|
||||
'autosummarize': True,
|
||||
'pages_per_range': 16,
|
||||
})
|
||||
self.assertEqual(
|
||||
kwargs,
|
||||
{
|
||||
"fields": ["title"],
|
||||
"name": "test_title_brin",
|
||||
"autosummarize": True,
|
||||
"pages_per_range": 16,
|
||||
},
|
||||
)
|
||||
|
||||
def test_invalid_pages_per_range(self):
|
||||
with self.assertRaisesMessage(ValueError, 'pages_per_range must be None or a positive integer'):
|
||||
BrinIndex(fields=['title'], name='test_title_brin', pages_per_range=0)
|
||||
with self.assertRaisesMessage(
|
||||
ValueError, "pages_per_range must be None or a positive integer"
|
||||
):
|
||||
BrinIndex(fields=["title"], name="test_title_brin", pages_per_range=0)
|
||||
|
||||
|
||||
class BTreeIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = BTreeIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(BTreeIndex.suffix, 'btree')
|
||||
self.assertEqual(BTreeIndex.suffix, "btree")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = BTreeIndex(fields=['title'], name='test_title_btree', fillfactor=80)
|
||||
index = BTreeIndex(fields=["title"], name="test_title_btree", fillfactor=80)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.BTreeIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.BTreeIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {'fields': ['title'], 'name': 'test_title_btree', 'fillfactor': 80})
|
||||
self.assertEqual(
|
||||
kwargs, {"fields": ["title"], "name": "test_title_btree", "fillfactor": 80}
|
||||
)
|
||||
|
||||
|
||||
class GinIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = GinIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(GinIndex.suffix, 'gin')
|
||||
self.assertEqual(GinIndex.suffix, "gin")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = GinIndex(
|
||||
fields=['title'],
|
||||
name='test_title_gin',
|
||||
fields=["title"],
|
||||
name="test_title_gin",
|
||||
fastupdate=True,
|
||||
gin_pending_list_limit=128,
|
||||
)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.GinIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.GinIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {
|
||||
'fields': ['title'],
|
||||
'name': 'test_title_gin',
|
||||
'fastupdate': True,
|
||||
'gin_pending_list_limit': 128,
|
||||
})
|
||||
self.assertEqual(
|
||||
kwargs,
|
||||
{
|
||||
"fields": ["title"],
|
||||
"name": "test_title_gin",
|
||||
"fastupdate": True,
|
||||
"gin_pending_list_limit": 128,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
class GistIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = GistIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(GistIndex.suffix, 'gist')
|
||||
self.assertEqual(GistIndex.suffix, "gist")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = GistIndex(fields=['title'], name='test_title_gist', buffering=False, fillfactor=80)
|
||||
index = GistIndex(
|
||||
fields=["title"], name="test_title_gist", buffering=False, fillfactor=80
|
||||
)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.GistIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.GistIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {
|
||||
'fields': ['title'],
|
||||
'name': 'test_title_gist',
|
||||
'buffering': False,
|
||||
'fillfactor': 80,
|
||||
})
|
||||
self.assertEqual(
|
||||
kwargs,
|
||||
{
|
||||
"fields": ["title"],
|
||||
"name": "test_title_gist",
|
||||
"buffering": False,
|
||||
"fillfactor": 80,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
class HashIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = HashIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(HashIndex.suffix, 'hash')
|
||||
self.assertEqual(HashIndex.suffix, "hash")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = HashIndex(fields=['title'], name='test_title_hash', fillfactor=80)
|
||||
index = HashIndex(fields=["title"], name="test_title_hash", fillfactor=80)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.HashIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.HashIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {'fields': ['title'], 'name': 'test_title_hash', 'fillfactor': 80})
|
||||
self.assertEqual(
|
||||
kwargs, {"fields": ["title"], "name": "test_title_hash", "fillfactor": 80}
|
||||
)
|
||||
|
||||
|
||||
class SpGistIndexTests(IndexTestMixin, PostgreSQLSimpleTestCase):
|
||||
index_class = SpGistIndex
|
||||
|
||||
def test_suffix(self):
|
||||
self.assertEqual(SpGistIndex.suffix, 'spgist')
|
||||
self.assertEqual(SpGistIndex.suffix, "spgist")
|
||||
|
||||
def test_deconstruction(self):
|
||||
index = SpGistIndex(fields=['title'], name='test_title_spgist', fillfactor=80)
|
||||
index = SpGistIndex(fields=["title"], name="test_title_spgist", fillfactor=80)
|
||||
path, args, kwargs = index.deconstruct()
|
||||
self.assertEqual(path, 'django.contrib.postgres.indexes.SpGistIndex')
|
||||
self.assertEqual(path, "django.contrib.postgres.indexes.SpGistIndex")
|
||||
self.assertEqual(args, ())
|
||||
self.assertEqual(kwargs, {'fields': ['title'], 'name': 'test_title_spgist', 'fillfactor': 80})
|
||||
self.assertEqual(
|
||||
kwargs, {"fields": ["title"], "name": "test_title_spgist", "fillfactor": 80}
|
||||
)
|
||||
|
||||
|
||||
@modify_settings(INSTALLED_APPS={'append': 'django.contrib.postgres'})
|
||||
@modify_settings(INSTALLED_APPS={"append": "django.contrib.postgres"})
|
||||
class SchemaTests(PostgreSQLTestCase):
|
||||
get_opclass_query = '''
|
||||
get_opclass_query = """
|
||||
SELECT opcname, c.relname FROM pg_opclass AS oc
|
||||
JOIN pg_index as i on oc.oid = ANY(i.indclass)
|
||||
JOIN pg_class as c on c.oid = i.indexrelid
|
||||
WHERE c.relname = %s
|
||||
'''
|
||||
"""
|
||||
|
||||
def get_constraints(self, table):
|
||||
"""
|
||||
|
|
@ -211,229 +252,274 @@ class SchemaTests(PostgreSQLTestCase):
|
|||
|
||||
def test_gin_index(self):
|
||||
# Ensure the table is there and doesn't have an index.
|
||||
self.assertNotIn('field', self.get_constraints(IntegerArrayModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
"field", self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
)
|
||||
# Add the index
|
||||
index_name = 'integer_array_model_field_gin'
|
||||
index = GinIndex(fields=['field'], name=index_name)
|
||||
index_name = "integer_array_model_field_gin"
|
||||
index = GinIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(IntegerArrayModel, index)
|
||||
constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
# Check gin index was added
|
||||
self.assertEqual(constraints[index_name]['type'], GinIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], GinIndex.suffix)
|
||||
# Drop the index
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(IntegerArrayModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(IntegerArrayModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_gin_fastupdate(self):
|
||||
index_name = 'integer_array_gin_fastupdate'
|
||||
index = GinIndex(fields=['field'], name=index_name, fastupdate=False)
|
||||
index_name = "integer_array_gin_fastupdate"
|
||||
index = GinIndex(fields=["field"], name=index_name, fastupdate=False)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(IntegerArrayModel, index)
|
||||
constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], 'gin')
|
||||
self.assertEqual(constraints[index_name]['options'], ['fastupdate=off'])
|
||||
self.assertEqual(constraints[index_name]["type"], "gin")
|
||||
self.assertEqual(constraints[index_name]["options"], ["fastupdate=off"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(IntegerArrayModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(IntegerArrayModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_partial_gin_index(self):
|
||||
with register_lookup(CharField, Length):
|
||||
index_name = 'char_field_gin_partial_idx'
|
||||
index = GinIndex(fields=['field'], name=index_name, condition=Q(field__length=40))
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], 'gin')
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
|
||||
def test_partial_gin_index_with_tablespace(self):
|
||||
with register_lookup(CharField, Length):
|
||||
index_name = 'char_field_gin_partial_idx'
|
||||
index_name = "char_field_gin_partial_idx"
|
||||
index = GinIndex(
|
||||
fields=['field'],
|
||||
name=index_name,
|
||||
condition=Q(field__length=40),
|
||||
db_tablespace='pg_default',
|
||||
fields=["field"], name=index_name, condition=Q(field__length=40)
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
self.assertIn('TABLESPACE "pg_default" ', str(index.create_sql(CharFieldModel, editor)))
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], 'gin')
|
||||
self.assertEqual(constraints[index_name]["type"], "gin")
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_partial_gin_index_with_tablespace(self):
|
||||
with register_lookup(CharField, Length):
|
||||
index_name = "char_field_gin_partial_idx"
|
||||
index = GinIndex(
|
||||
fields=["field"],
|
||||
name=index_name,
|
||||
condition=Q(field__length=40),
|
||||
db_tablespace="pg_default",
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
self.assertIn(
|
||||
'TABLESPACE "pg_default" ',
|
||||
str(index.create_sql(CharFieldModel, editor)),
|
||||
)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]["type"], "gin")
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_gin_parameters(self):
|
||||
index_name = 'integer_array_gin_params'
|
||||
index = GinIndex(fields=['field'], name=index_name, fastupdate=True, gin_pending_list_limit=64)
|
||||
index_name = "integer_array_gin_params"
|
||||
index = GinIndex(
|
||||
fields=["field"],
|
||||
name=index_name,
|
||||
fastupdate=True,
|
||||
gin_pending_list_limit=64,
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(IntegerArrayModel, index)
|
||||
constraints = self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], 'gin')
|
||||
self.assertEqual(constraints[index_name]['options'], ['gin_pending_list_limit=64', 'fastupdate=on'])
|
||||
self.assertEqual(constraints[index_name]["type"], "gin")
|
||||
self.assertEqual(
|
||||
constraints[index_name]["options"],
|
||||
["gin_pending_list_limit=64", "fastupdate=on"],
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(IntegerArrayModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(IntegerArrayModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(IntegerArrayModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_trigram_op_class_gin_index(self):
|
||||
index_name = 'trigram_op_class_gin'
|
||||
index = GinIndex(OpClass(F('scene'), name='gin_trgm_ops'), name=index_name)
|
||||
index_name = "trigram_op_class_gin"
|
||||
index = GinIndex(OpClass(F("scene"), name="gin_trgm_ops"), name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(Scene, index)
|
||||
with editor.connection.cursor() as cursor:
|
||||
cursor.execute(self.get_opclass_query, [index_name])
|
||||
self.assertCountEqual(cursor.fetchall(), [('gin_trgm_ops', index_name)])
|
||||
self.assertCountEqual(cursor.fetchall(), [("gin_trgm_ops", index_name)])
|
||||
constraints = self.get_constraints(Scene._meta.db_table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertIn(constraints[index_name]['type'], GinIndex.suffix)
|
||||
self.assertIn(constraints[index_name]["type"], GinIndex.suffix)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(Scene, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
|
||||
|
||||
def test_cast_search_vector_gin_index(self):
|
||||
index_name = 'cast_search_vector_gin'
|
||||
index = GinIndex(Cast('field', SearchVectorField()), name=index_name)
|
||||
index_name = "cast_search_vector_gin"
|
||||
index = GinIndex(Cast("field", SearchVectorField()), name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
sql = index.create_sql(TextFieldModel, editor)
|
||||
table = TextFieldModel._meta.db_table
|
||||
constraints = self.get_constraints(table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertIn(constraints[index_name]['type'], GinIndex.suffix)
|
||||
self.assertIs(sql.references_column(table, 'field'), True)
|
||||
self.assertIn('::tsvector', str(sql))
|
||||
self.assertIn(constraints[index_name]["type"], GinIndex.suffix)
|
||||
self.assertIs(sql.references_column(table, "field"), True)
|
||||
self.assertIn("::tsvector", str(sql))
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(TextFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(table))
|
||||
|
||||
def test_bloom_index(self):
|
||||
index_name = 'char_field_model_field_bloom'
|
||||
index = BloomIndex(fields=['field'], name=index_name)
|
||||
index_name = "char_field_model_field_bloom"
|
||||
index = BloomIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], BloomIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], BloomIndex.suffix)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_bloom_parameters(self):
|
||||
index_name = 'char_field_model_field_bloom_params'
|
||||
index = BloomIndex(fields=['field'], name=index_name, length=512, columns=[3])
|
||||
index_name = "char_field_model_field_bloom_params"
|
||||
index = BloomIndex(fields=["field"], name=index_name, length=512, columns=[3])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], BloomIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['length=512', 'col1=3'])
|
||||
self.assertEqual(constraints[index_name]["type"], BloomIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["length=512", "col1=3"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_brin_index(self):
|
||||
index_name = 'char_field_model_field_brin'
|
||||
index = BrinIndex(fields=['field'], name=index_name, pages_per_range=4)
|
||||
index_name = "char_field_model_field_brin"
|
||||
index = BrinIndex(fields=["field"], name=index_name, pages_per_range=4)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], BrinIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['pages_per_range=4'])
|
||||
self.assertEqual(constraints[index_name]["type"], BrinIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["pages_per_range=4"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_brin_parameters(self):
|
||||
index_name = 'char_field_brin_params'
|
||||
index = BrinIndex(fields=['field'], name=index_name, autosummarize=True)
|
||||
index_name = "char_field_brin_params"
|
||||
index = BrinIndex(fields=["field"], name=index_name, autosummarize=True)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], BrinIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['autosummarize=on'])
|
||||
self.assertEqual(constraints[index_name]["type"], BrinIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["autosummarize=on"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_btree_index(self):
|
||||
# Ensure the table is there and doesn't have an index.
|
||||
self.assertNotIn('field', self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
|
||||
# Add the index.
|
||||
index_name = 'char_field_model_field_btree'
|
||||
index = BTreeIndex(fields=['field'], name=index_name)
|
||||
index_name = "char_field_model_field_btree"
|
||||
index = BTreeIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
# The index was added.
|
||||
self.assertEqual(constraints[index_name]['type'], BTreeIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], BTreeIndex.suffix)
|
||||
# Drop the index.
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_btree_parameters(self):
|
||||
index_name = 'integer_array_btree_fillfactor'
|
||||
index = BTreeIndex(fields=['field'], name=index_name, fillfactor=80)
|
||||
index_name = "integer_array_btree_fillfactor"
|
||||
index = BTreeIndex(fields=["field"], name=index_name, fillfactor=80)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], BTreeIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['fillfactor=80'])
|
||||
self.assertEqual(constraints[index_name]["type"], BTreeIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_gist_index(self):
|
||||
# Ensure the table is there and doesn't have an index.
|
||||
self.assertNotIn('field', self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
|
||||
# Add the index.
|
||||
index_name = 'char_field_model_field_gist'
|
||||
index = GistIndex(fields=['field'], name=index_name)
|
||||
index_name = "char_field_model_field_gist"
|
||||
index = GistIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
# The index was added.
|
||||
self.assertEqual(constraints[index_name]['type'], GistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
|
||||
# Drop the index.
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_gist_parameters(self):
|
||||
index_name = 'integer_array_gist_buffering'
|
||||
index = GistIndex(fields=['field'], name=index_name, buffering=True, fillfactor=80)
|
||||
index_name = "integer_array_gist_buffering"
|
||||
index = GistIndex(
|
||||
fields=["field"], name=index_name, buffering=True, fillfactor=80
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], GistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['buffering=on', 'fillfactor=80'])
|
||||
self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
|
||||
self.assertEqual(
|
||||
constraints[index_name]["options"], ["buffering=on", "fillfactor=80"]
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature('supports_covering_gist_indexes')
|
||||
@skipUnlessDBFeature("supports_covering_gist_indexes")
|
||||
def test_gist_include(self):
|
||||
index_name = 'scene_gist_include_setting'
|
||||
index = GistIndex(name=index_name, fields=['scene'], include=['setting'])
|
||||
index_name = "scene_gist_include_setting"
|
||||
index = GistIndex(name=index_name, fields=["scene"], include=["setting"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(Scene, index)
|
||||
constraints = self.get_constraints(Scene._meta.db_table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertEqual(constraints[index_name]['type'], GistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['columns'], ['scene', 'setting'])
|
||||
self.assertEqual(constraints[index_name]["type"], GistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["columns"], ["scene", "setting"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(Scene, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
|
||||
|
||||
def test_gist_include_not_supported(self):
|
||||
index_name = 'gist_include_exception'
|
||||
index = GistIndex(fields=['scene'], name=index_name, include=['setting'])
|
||||
msg = 'Covering GiST indexes require PostgreSQL 12+.'
|
||||
index_name = "gist_include_exception"
|
||||
index = GistIndex(fields=["scene"], name=index_name, include=["setting"])
|
||||
msg = "Covering GiST indexes require PostgreSQL 12+."
|
||||
with self.assertRaisesMessage(NotSupportedError, msg):
|
||||
with mock.patch(
|
||||
'django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_gist_indexes',
|
||||
"django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_gist_indexes",
|
||||
False,
|
||||
):
|
||||
with connection.schema_editor() as editor:
|
||||
|
|
@ -441,11 +527,11 @@ class SchemaTests(PostgreSQLTestCase):
|
|||
self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
|
||||
|
||||
def test_tsvector_op_class_gist_index(self):
|
||||
index_name = 'tsvector_op_class_gist'
|
||||
index_name = "tsvector_op_class_gist"
|
||||
index = GistIndex(
|
||||
OpClass(
|
||||
SearchVector('scene', 'setting', config='english'),
|
||||
name='tsvector_ops',
|
||||
SearchVector("scene", "setting", config="english"),
|
||||
name="tsvector_ops",
|
||||
),
|
||||
name=index_name,
|
||||
)
|
||||
|
|
@ -455,90 +541,98 @@ class SchemaTests(PostgreSQLTestCase):
|
|||
table = Scene._meta.db_table
|
||||
constraints = self.get_constraints(table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertIn(constraints[index_name]['type'], GistIndex.suffix)
|
||||
self.assertIs(sql.references_column(table, 'scene'), True)
|
||||
self.assertIs(sql.references_column(table, 'setting'), True)
|
||||
self.assertIn(constraints[index_name]["type"], GistIndex.suffix)
|
||||
self.assertIs(sql.references_column(table, "scene"), True)
|
||||
self.assertIs(sql.references_column(table, "setting"), True)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(Scene, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(table))
|
||||
|
||||
def test_hash_index(self):
|
||||
# Ensure the table is there and doesn't have an index.
|
||||
self.assertNotIn('field', self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn("field", self.get_constraints(CharFieldModel._meta.db_table))
|
||||
# Add the index.
|
||||
index_name = 'char_field_model_field_hash'
|
||||
index = HashIndex(fields=['field'], name=index_name)
|
||||
index_name = "char_field_model_field_hash"
|
||||
index = HashIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
# The index was added.
|
||||
self.assertEqual(constraints[index_name]['type'], HashIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], HashIndex.suffix)
|
||||
# Drop the index.
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_hash_parameters(self):
|
||||
index_name = 'integer_array_hash_fillfactor'
|
||||
index = HashIndex(fields=['field'], name=index_name, fillfactor=80)
|
||||
index_name = "integer_array_hash_fillfactor"
|
||||
index = HashIndex(fields=["field"], name=index_name, fillfactor=80)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(CharFieldModel, index)
|
||||
constraints = self.get_constraints(CharFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], HashIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['fillfactor=80'])
|
||||
self.assertEqual(constraints[index_name]["type"], HashIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(CharFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(CharFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(CharFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_spgist_index(self):
|
||||
# Ensure the table is there and doesn't have an index.
|
||||
self.assertNotIn('field', self.get_constraints(TextFieldModel._meta.db_table))
|
||||
self.assertNotIn("field", self.get_constraints(TextFieldModel._meta.db_table))
|
||||
# Add the index.
|
||||
index_name = 'text_field_model_field_spgist'
|
||||
index = SpGistIndex(fields=['field'], name=index_name)
|
||||
index_name = "text_field_model_field_spgist"
|
||||
index = SpGistIndex(fields=["field"], name=index_name)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
constraints = self.get_constraints(TextFieldModel._meta.db_table)
|
||||
# The index was added.
|
||||
self.assertEqual(constraints[index_name]['type'], SpGistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
|
||||
# Drop the index.
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(TextFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(TextFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(TextFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
def test_spgist_parameters(self):
|
||||
index_name = 'text_field_model_spgist_fillfactor'
|
||||
index = SpGistIndex(fields=['field'], name=index_name, fillfactor=80)
|
||||
index_name = "text_field_model_spgist_fillfactor"
|
||||
index = SpGistIndex(fields=["field"], name=index_name, fillfactor=80)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
constraints = self.get_constraints(TextFieldModel._meta.db_table)
|
||||
self.assertEqual(constraints[index_name]['type'], SpGistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['options'], ['fillfactor=80'])
|
||||
self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["options"], ["fillfactor=80"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(TextFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(TextFieldModel._meta.db_table))
|
||||
self.assertNotIn(
|
||||
index_name, self.get_constraints(TextFieldModel._meta.db_table)
|
||||
)
|
||||
|
||||
@skipUnlessDBFeature('supports_covering_spgist_indexes')
|
||||
@skipUnlessDBFeature("supports_covering_spgist_indexes")
|
||||
def test_spgist_include(self):
|
||||
index_name = 'scene_spgist_include_setting'
|
||||
index = SpGistIndex(name=index_name, fields=['scene'], include=['setting'])
|
||||
index_name = "scene_spgist_include_setting"
|
||||
index = SpGistIndex(name=index_name, fields=["scene"], include=["setting"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(Scene, index)
|
||||
constraints = self.get_constraints(Scene._meta.db_table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertEqual(constraints[index_name]['type'], SpGistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]['columns'], ['scene', 'setting'])
|
||||
self.assertEqual(constraints[index_name]["type"], SpGistIndex.suffix)
|
||||
self.assertEqual(constraints[index_name]["columns"], ["scene", "setting"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(Scene, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
|
||||
|
||||
def test_spgist_include_not_supported(self):
|
||||
index_name = 'spgist_include_exception'
|
||||
index = SpGistIndex(fields=['scene'], name=index_name, include=['setting'])
|
||||
msg = 'Covering SP-GiST indexes require PostgreSQL 14+.'
|
||||
index_name = "spgist_include_exception"
|
||||
index = SpGistIndex(fields=["scene"], name=index_name, include=["setting"])
|
||||
msg = "Covering SP-GiST indexes require PostgreSQL 14+."
|
||||
with self.assertRaisesMessage(NotSupportedError, msg):
|
||||
with mock.patch(
|
||||
'django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_spgist_indexes',
|
||||
"django.db.backends.postgresql.features.DatabaseFeatures.supports_covering_spgist_indexes",
|
||||
False,
|
||||
):
|
||||
with connection.schema_editor() as editor:
|
||||
|
|
@ -546,27 +640,25 @@ class SchemaTests(PostgreSQLTestCase):
|
|||
self.assertNotIn(index_name, self.get_constraints(Scene._meta.db_table))
|
||||
|
||||
def test_op_class(self):
|
||||
index_name = 'test_op_class'
|
||||
index_name = "test_op_class"
|
||||
index = Index(
|
||||
OpClass(Lower('field'), name='text_pattern_ops'),
|
||||
OpClass(Lower("field"), name="text_pattern_ops"),
|
||||
name=index_name,
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
with editor.connection.cursor() as cursor:
|
||||
cursor.execute(self.get_opclass_query, [index_name])
|
||||
self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
|
||||
self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
|
||||
|
||||
def test_op_class_descending_collation(self):
|
||||
collation = connection.features.test_collations.get('non_default')
|
||||
collation = connection.features.test_collations.get("non_default")
|
||||
if not collation:
|
||||
self.skipTest(
|
||||
'This backend does not support case-insensitive collations.'
|
||||
)
|
||||
index_name = 'test_op_class_descending_collation'
|
||||
self.skipTest("This backend does not support case-insensitive collations.")
|
||||
index_name = "test_op_class_descending_collation"
|
||||
index = Index(
|
||||
Collate(
|
||||
OpClass(Lower('field'), name='text_pattern_ops').desc(nulls_last=True),
|
||||
OpClass(Lower("field"), name="text_pattern_ops").desc(nulls_last=True),
|
||||
collation=collation,
|
||||
),
|
||||
name=index_name,
|
||||
|
|
@ -574,53 +666,53 @@ class SchemaTests(PostgreSQLTestCase):
|
|||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
self.assertIn(
|
||||
'COLLATE %s' % editor.quote_name(collation),
|
||||
"COLLATE %s" % editor.quote_name(collation),
|
||||
str(index.create_sql(TextFieldModel, editor)),
|
||||
)
|
||||
with editor.connection.cursor() as cursor:
|
||||
cursor.execute(self.get_opclass_query, [index_name])
|
||||
self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
|
||||
self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
|
||||
table = TextFieldModel._meta.db_table
|
||||
constraints = self.get_constraints(table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertEqual(constraints[index_name]['orders'], ['DESC'])
|
||||
self.assertEqual(constraints[index_name]["orders"], ["DESC"])
|
||||
with connection.schema_editor() as editor:
|
||||
editor.remove_index(TextFieldModel, index)
|
||||
self.assertNotIn(index_name, self.get_constraints(table))
|
||||
|
||||
def test_op_class_descending_partial(self):
|
||||
index_name = 'test_op_class_descending_partial'
|
||||
index_name = "test_op_class_descending_partial"
|
||||
index = Index(
|
||||
OpClass(Lower('field'), name='text_pattern_ops').desc(),
|
||||
OpClass(Lower("field"), name="text_pattern_ops").desc(),
|
||||
name=index_name,
|
||||
condition=Q(field__contains='China'),
|
||||
condition=Q(field__contains="China"),
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
with editor.connection.cursor() as cursor:
|
||||
cursor.execute(self.get_opclass_query, [index_name])
|
||||
self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
|
||||
self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
|
||||
constraints = self.get_constraints(TextFieldModel._meta.db_table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertEqual(constraints[index_name]['orders'], ['DESC'])
|
||||
self.assertEqual(constraints[index_name]["orders"], ["DESC"])
|
||||
|
||||
def test_op_class_descending_partial_tablespace(self):
|
||||
index_name = 'test_op_class_descending_partial_tablespace'
|
||||
index_name = "test_op_class_descending_partial_tablespace"
|
||||
index = Index(
|
||||
OpClass(Lower('field').desc(), name='text_pattern_ops'),
|
||||
OpClass(Lower("field").desc(), name="text_pattern_ops"),
|
||||
name=index_name,
|
||||
condition=Q(field__contains='China'),
|
||||
db_tablespace='pg_default',
|
||||
condition=Q(field__contains="China"),
|
||||
db_tablespace="pg_default",
|
||||
)
|
||||
with connection.schema_editor() as editor:
|
||||
editor.add_index(TextFieldModel, index)
|
||||
self.assertIn(
|
||||
'TABLESPACE "pg_default" ',
|
||||
str(index.create_sql(TextFieldModel, editor))
|
||||
str(index.create_sql(TextFieldModel, editor)),
|
||||
)
|
||||
with editor.connection.cursor() as cursor:
|
||||
cursor.execute(self.get_opclass_query, [index_name])
|
||||
self.assertCountEqual(cursor.fetchall(), [('text_pattern_ops', index_name)])
|
||||
self.assertCountEqual(cursor.fetchall(), [("text_pattern_ops", index_name)])
|
||||
constraints = self.get_constraints(TextFieldModel._meta.db_table)
|
||||
self.assertIn(index_name, constraints)
|
||||
self.assertEqual(constraints[index_name]['orders'], ['DESC'])
|
||||
self.assertEqual(constraints[index_name]["orders"], ["DESC"])
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue