| 1 |
from django.db import connection |
| 2 |
from django.db.backends.ddl_references import ( |
| 3 |
Columns, |
| 4 |
Expressions, |
| 5 |
ForeignKeyName, |
| 6 |
IndexName, |
| 7 |
Statement, |
| 8 |
Table, |
| 9 |
) |
| 10 |
from django.db.models import ExpressionList, F |
| 11 |
from django.db.models.functions import Upper |
| 12 |
from django.db.models.indexes import IndexExpression |
| 13 |
from django.db.models.sql import Query |
| 14 |
from django.test import SimpleTestCase, TransactionTestCase |
| 15 |
|
| 16 |
from .models import Person |
| 17 |
|
| 18 |
|
| 19 |
class TableTests(SimpleTestCase): |
| 20 |
def setUp(self): |
| 21 |
self.reference = Table("table", lambda table: table.upper()) |
| 22 |
|
| 23 |
def test_references_table(self): |
| 24 |
self.assertIs(self.reference.references_table("table"), True) |
| 25 |
self.assertIs(self.reference.references_table("other"), False) |
| 26 |
|
| 27 |
def test_rename_table_references(self): |
| 28 |
self.reference.rename_table_references("other", "table") |
| 29 |
self.assertIs(self.reference.references_table("table"), True) |
| 30 |
self.assertIs(self.reference.references_table("other"), False) |
| 31 |
self.reference.rename_table_references("table", "other") |
| 32 |
self.assertIs(self.reference.references_table("table"), False) |
| 33 |
self.assertIs(self.reference.references_table("other"), True) |
| 34 |
|
| 35 |
def test_repr(self): |
| 36 |
self.assertEqual(repr(self.reference), "<Table 'TABLE'>") |
| 37 |
|
| 38 |
def test_str(self): |
| 39 |
self.assertEqual(str(self.reference), "TABLE") |
| 40 |
|
| 41 |
|
| 42 |
class ColumnsTests(TableTests): |
| 43 |
def setUp(self): |
| 44 |
self.reference = Columns( |
| 45 |
"table", ["first_column", "second_column"], lambda column: column.upper() |
| 46 |
) |
| 47 |
|
| 48 |
def test_references_column(self): |
| 49 |
self.assertIs(self.reference.references_column("other", "first_column"), False) |
| 50 |
self.assertIs(self.reference.references_column("table", "third_column"), False) |
| 51 |
self.assertIs(self.reference.references_column("table", "first_column"), True) |
| 52 |
|
| 53 |
def test_rename_column_references(self): |
| 54 |
self.reference.rename_column_references("other", "first_column", "third_column") |
| 55 |
self.assertIs(self.reference.references_column("table", "first_column"), True) |
| 56 |
self.assertIs(self.reference.references_column("table", "third_column"), False) |
| 57 |
self.assertIs(self.reference.references_column("other", "third_column"), False) |
| 58 |
self.reference.rename_column_references("table", "third_column", "first_column") |
| 59 |
self.assertIs(self.reference.references_column("table", "first_column"), True) |
| 60 |
self.assertIs(self.reference.references_column("table", "third_column"), False) |
| 61 |
self.reference.rename_column_references("table", "first_column", "third_column") |
| 62 |
self.assertIs(self.reference.references_column("table", "first_column"), False) |
| 63 |
self.assertIs(self.reference.references_column("table", "third_column"), True) |
| 64 |
|
| 65 |
def test_repr(self): |
| 66 |
self.assertEqual( |
| 67 |
repr(self.reference), "<Columns 'FIRST_COLUMN, SECOND_COLUMN'>" |
| 68 |
) |
| 69 |
|
| 70 |
def test_str(self): |
| 71 |
self.assertEqual(str(self.reference), "FIRST_COLUMN, SECOND_COLUMN") |
| 72 |
|
| 73 |
|
| 74 |
class IndexNameTests(ColumnsTests): |
| 75 |
def setUp(self): |
| 76 |
def create_index_name(table_name, column_names, suffix): |
| 77 |
return ", ".join( |
| 78 |
"%s_%s_%s" % (table_name, column_name, suffix) |
| 79 |
for column_name in column_names |
| 80 |
) |
| 81 |
|
| 82 |
self.reference = IndexName( |
| 83 |
"table", ["first_column", "second_column"], "suffix", create_index_name |
| 84 |
) |
| 85 |
|
| 86 |
def test_repr(self): |
| 87 |
self.assertEqual( |
| 88 |
repr(self.reference), |
| 89 |
"<IndexName 'table_first_column_suffix, table_second_column_suffix'>", |
| 90 |
) |
| 91 |
|
| 92 |
def test_str(self): |
| 93 |
self.assertEqual( |
| 94 |
str(self.reference), "table_first_column_suffix, table_second_column_suffix" |
| 95 |
) |
| 96 |
|
| 97 |
|
| 98 |
class ForeignKeyNameTests(IndexNameTests): |
| 99 |
def setUp(self): |
| 100 |
def create_foreign_key_name(table_name, column_names, suffix): |
| 101 |
return ", ".join( |
| 102 |
"%s_%s_%s" % (table_name, column_name, suffix) |
| 103 |
for column_name in column_names |
| 104 |
) |
| 105 |
|
| 106 |
self.reference = ForeignKeyName( |
| 107 |
"table", |
| 108 |
["first_column", "second_column"], |
| 109 |
"to_table", |
| 110 |
["to_first_column", "to_second_column"], |
| 111 |
"%(to_table)s_%(to_column)s_fk", |
| 112 |
create_foreign_key_name, |
| 113 |
) |
| 114 |
|
| 115 |
def test_references_table(self): |
| 116 |
super().test_references_table() |
| 117 |
self.assertIs(self.reference.references_table("to_table"), True) |
| 118 |
|
| 119 |
def test_references_column(self): |
| 120 |
super().test_references_column() |
| 121 |
self.assertIs( |
| 122 |
self.reference.references_column("to_table", "second_column"), False |
| 123 |
) |
| 124 |
self.assertIs( |
| 125 |
self.reference.references_column("to_table", "to_second_column"), True |
| 126 |
) |
| 127 |
|
| 128 |
def test_rename_table_references(self): |
| 129 |
super().test_rename_table_references() |
| 130 |
self.reference.rename_table_references("to_table", "other_to_table") |
| 131 |
self.assertIs(self.reference.references_table("other_to_table"), True) |
| 132 |
self.assertIs(self.reference.references_table("to_table"), False) |
| 133 |
|
| 134 |
def test_rename_column_references(self): |
| 135 |
super().test_rename_column_references() |
| 136 |
self.reference.rename_column_references( |
| 137 |
"to_table", "second_column", "third_column" |
| 138 |
) |
| 139 |
self.assertIs(self.reference.references_column("table", "second_column"), True) |
| 140 |
self.assertIs( |
| 141 |
self.reference.references_column("to_table", "to_second_column"), True |
| 142 |
) |
| 143 |
self.reference.rename_column_references( |
| 144 |
"to_table", "to_first_column", "to_third_column" |
| 145 |
) |
| 146 |
self.assertIs( |
| 147 |
self.reference.references_column("to_table", "to_first_column"), False |
| 148 |
) |
| 149 |
self.assertIs( |
| 150 |
self.reference.references_column("to_table", "to_third_column"), True |
| 151 |
) |
| 152 |
|
| 153 |
def test_repr(self): |
| 154 |
self.assertEqual( |
| 155 |
repr(self.reference), |
| 156 |
"<ForeignKeyName 'table_first_column_to_table_to_first_column_fk, " |
| 157 |
"table_second_column_to_table_to_first_column_fk'>", |
| 158 |
) |
| 159 |
|
| 160 |
def test_str(self): |
| 161 |
self.assertEqual( |
| 162 |
str(self.reference), |
| 163 |
"table_first_column_to_table_to_first_column_fk, " |
| 164 |
"table_second_column_to_table_to_first_column_fk", |
| 165 |
) |
| 166 |
|
| 167 |
|
| 168 |
class MockReference: |
| 169 |
def __init__( |
| 170 |
self, representation, referenced_tables, referenced_columns, referenced_indexes |
| 171 |
): |
| 172 |
self.representation = representation |
| 173 |
self.referenced_tables = referenced_tables |
| 174 |
self.referenced_columns = referenced_columns |
| 175 |
self.referenced_indexes = referenced_indexes |
| 176 |
|
| 177 |
def references_table(self, table): |
| 178 |
return table in self.referenced_tables |
| 179 |
|
| 180 |
def references_column(self, table, column): |
| 181 |
return (table, column) in self.referenced_columns |
| 182 |
|
| 183 |
def references_index(self, table, index): |
| 184 |
return (table, index) in self.referenced_indexes |
| 185 |
|
| 186 |
def rename_table_references(self, old_table, new_table): |
| 187 |
if old_table in self.referenced_tables: |
| 188 |
self.referenced_tables.remove(old_table) |
| 189 |
self.referenced_tables.add(new_table) |
| 190 |
|
| 191 |
def rename_column_references(self, table, old_column, new_column): |
| 192 |
column = (table, old_column) |
| 193 |
if column in self.referenced_columns: |
| 194 |
self.referenced_columns.remove(column) |
| 195 |
self.referenced_columns.add((table, new_column)) |
| 196 |
|
| 197 |
def __str__(self): |
| 198 |
return self.representation |
| 199 |
|
| 200 |
|
| 201 |
class StatementTests(SimpleTestCase): |
| 202 |
def test_references_table(self): |
| 203 |
statement = Statement( |
| 204 |
"", reference=MockReference("", {"table"}, {}, {}), non_reference="" |
| 205 |
) |
| 206 |
self.assertIs(statement.references_table("table"), True) |
| 207 |
self.assertIs(statement.references_table("other"), False) |
| 208 |
|
| 209 |
def test_references_column(self): |
| 210 |
statement = Statement( |
| 211 |
"", |
| 212 |
reference=MockReference("", {}, {("table", "column")}, {}), |
| 213 |
non_reference="", |
| 214 |
) |
| 215 |
self.assertIs(statement.references_column("table", "column"), True) |
| 216 |
self.assertIs(statement.references_column("other", "column"), False) |
| 217 |
|
| 218 |
def test_references_index(self): |
| 219 |
statement = Statement( |
| 220 |
"", |
| 221 |
reference=MockReference("", {}, {}, {("table", "index")}), |
| 222 |
non_reference="", |
| 223 |
) |
| 224 |
self.assertIs(statement.references_index("table", "index"), True) |
| 225 |
self.assertIs(statement.references_index("other", "index"), False) |
| 226 |
|
| 227 |
def test_rename_table_references(self): |
| 228 |
reference = MockReference("", {"table"}, {}, {}) |
| 229 |
statement = Statement("", reference=reference, non_reference="") |
| 230 |
statement.rename_table_references("table", "other") |
| 231 |
self.assertEqual(reference.referenced_tables, {"other"}) |
| 232 |
|
| 233 |
def test_rename_column_references(self): |
| 234 |
reference = MockReference("", {}, {("table", "column")}, {}) |
| 235 |
statement = Statement("", reference=reference, non_reference="") |
| 236 |
statement.rename_column_references("table", "column", "other") |
| 237 |
self.assertEqual(reference.referenced_columns, {("table", "other")}) |
| 238 |
|
| 239 |
def test_repr(self): |
| 240 |
reference = MockReference("reference", {}, {}, {}) |
| 241 |
statement = Statement( |
| 242 |
"%(reference)s - %(non_reference)s", |
| 243 |
reference=reference, |
| 244 |
non_reference="non_reference", |
| 245 |
) |
| 246 |
self.assertEqual(repr(statement), "<Statement 'reference - non_reference'>") |
| 247 |
|
| 248 |
def test_str(self): |
| 249 |
reference = MockReference("reference", {}, {}, {}) |
| 250 |
statement = Statement( |
| 251 |
"%(reference)s - %(non_reference)s", |
| 252 |
reference=reference, |
| 253 |
non_reference="non_reference", |
| 254 |
) |
| 255 |
self.assertEqual(str(statement), "reference - non_reference") |
| 256 |
|
| 257 |
|
| 258 |
class ExpressionsTests(TransactionTestCase): |
| 259 |
available_apps = [] |
| 260 |
|
| 261 |
def setUp(self): |
| 262 |
compiler = Person.objects.all().query.get_compiler(connection.alias) |
| 263 |
self.editor = connection.schema_editor() |
| 264 |
self.expressions = Expressions( |
| 265 |
table=Person._meta.db_table, |
| 266 |
expressions=ExpressionList( |
| 267 |
IndexExpression(F("first_name")), |
| 268 |
IndexExpression(F("last_name").desc()), |
| 269 |
IndexExpression(Upper("last_name")), |
| 270 |
).resolve_expression(compiler.query), |
| 271 |
compiler=compiler, |
| 272 |
quote_value=self.editor.quote_value, |
| 273 |
) |
| 274 |
|
| 275 |
def test_references_table(self): |
| 276 |
self.assertIs(self.expressions.references_table(Person._meta.db_table), True) |
| 277 |
self.assertIs(self.expressions.references_table("other"), False) |
| 278 |
|
| 279 |
def test_references_column(self): |
| 280 |
table = Person._meta.db_table |
| 281 |
self.assertIs(self.expressions.references_column(table, "first_name"), True) |
| 282 |
self.assertIs(self.expressions.references_column(table, "last_name"), True) |
| 283 |
self.assertIs(self.expressions.references_column(table, "other"), False) |
| 284 |
|
| 285 |
def test_rename_table_references(self): |
| 286 |
table = Person._meta.db_table |
| 287 |
self.expressions.rename_table_references(table, "other") |
| 288 |
self.assertIs(self.expressions.references_table(table), False) |
| 289 |
self.assertIs(self.expressions.references_table("other"), True) |
| 290 |
self.assertIn( |
| 291 |
"%s.%s" |
| 292 |
% ( |
| 293 |
self.editor.quote_name("other"), |
| 294 |
self.editor.quote_name("first_name"), |
| 295 |
), |
| 296 |
str(self.expressions), |
| 297 |
) |
| 298 |
|
| 299 |
def test_rename_table_references_without_alias(self): |
| 300 |
compiler = Query(Person, alias_cols=False).get_compiler(connection=connection) |
| 301 |
table = Person._meta.db_table |
| 302 |
expressions = Expressions( |
| 303 |
table=table, |
| 304 |
expressions=ExpressionList( |
| 305 |
IndexExpression(Upper("last_name")), |
| 306 |
IndexExpression(F("first_name")), |
| 307 |
).resolve_expression(compiler.query), |
| 308 |
compiler=compiler, |
| 309 |
quote_value=self.editor.quote_value, |
| 310 |
) |
| 311 |
expressions.rename_table_references(table, "other") |
| 312 |
self.assertIs(expressions.references_table(table), False) |
| 313 |
self.assertIs(expressions.references_table("other"), True) |
| 314 |
expected_str = "(UPPER(%s)), %s" % ( |
| 315 |
self.editor.quote_name("last_name"), |
| 316 |
self.editor.quote_name("first_name"), |
| 317 |
) |
| 318 |
self.assertEqual(str(expressions), expected_str) |
| 319 |
|
| 320 |
def test_rename_column_references(self): |
| 321 |
table = Person._meta.db_table |
| 322 |
self.expressions.rename_column_references(table, "first_name", "other") |
| 323 |
self.assertIs(self.expressions.references_column(table, "other"), True) |
| 324 |
self.assertIs(self.expressions.references_column(table, "first_name"), False) |
| 325 |
self.assertIn( |
| 326 |
"%s.%s" % (self.editor.quote_name(table), self.editor.quote_name("other")), |
| 327 |
str(self.expressions), |
| 328 |
) |
| 329 |
|
| 330 |
def test_str(self): |
| 331 |
table_name = self.editor.quote_name(Person._meta.db_table) |
| 332 |
expected_str = "%s.%s, %s.%s DESC, (UPPER(%s.%s))" % ( |
| 333 |
table_name, |
| 334 |
self.editor.quote_name("first_name"), |
| 335 |
table_name, |
| 336 |
self.editor.quote_name("last_name"), |
| 337 |
table_name, |
| 338 |
self.editor.quote_name("last_name"), |
| 339 |
) |
| 340 |
self.assertEqual(str(self.expressions), expected_str) |