1. import unittest

  2. 

  3. from django.core.management.color import no_style

  4. from django.db import connection

  5. from django.test import TransactionTestCase

  6. 

  7. from ..models import Person, Tag

  8. 

  9. 

  10. @unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")

  11. class OperationsTests(TransactionTestCase):

  12.     available_apps = ["backends"]

  13. 

  14.     def test_sequence_name_truncation(self):

  15.         seq_name = connection.ops._get_no_autofield_sequence_name(

  16.             "schema_authorwithevenlongee869"

  17.         )

  18.         self.assertEqual(seq_name, "SCHEMA_AUTHORWITHEVENLOB0B8_SQ")

  19. 

  20.     def test_bulk_batch_size(self):

  21.         # Oracle restricts the number of parameters in a query.

  22.         objects = range(2**16)

  23.         self.assertEqual(connection.ops.bulk_batch_size([], objects), len(objects))

  24.         # Each field is a parameter for each object.

  25.         self.assertEqual(

  26.             connection.ops.bulk_batch_size(["id"], objects),

  27.             connection.features.max_query_params,

  28.         )

  29.         self.assertEqual(

  30.             connection.ops.bulk_batch_size(["id", "other"], objects),

  31.             connection.features.max_query_params // 2,

  32.         )

  33. 

  34.     def test_sql_flush(self):

  35.         statements = connection.ops.sql_flush(

  36.             no_style(),

  37.             [Person._meta.db_table, Tag._meta.db_table],

  38.         )

  39.         # The tables and constraints are processed in an unordered set.

  40.         self.assertEqual(

  41.             statements[0],

  42.             'ALTER TABLE "BACKENDS_TAG" DISABLE CONSTRAINT '

  43.             '"BACKENDS__CONTENT_T_FD9D7A85_F" KEEP INDEX;',

  44.         )

  45.         self.assertEqual(

  46.             sorted(statements[1:-1]),

  47.             [

  48.                 'TRUNCATE TABLE "BACKENDS_PERSON";',

  49.                 'TRUNCATE TABLE "BACKENDS_TAG";',

  50.             ],

  51.         )

  52.         self.assertEqual(

  53.             statements[-1],

  54.             'ALTER TABLE "BACKENDS_TAG" ENABLE CONSTRAINT '

  55.             '"BACKENDS__CONTENT_T_FD9D7A85_F";',

  56.         )

  57. 

  58.     def test_sql_flush_allow_cascade(self):

  59.         statements = connection.ops.sql_flush(

  60.             no_style(),

  61.             [Person._meta.db_table, Tag._meta.db_table],

  62.             allow_cascade=True,

  63.         )

  64.         # The tables and constraints are processed in an unordered set.

  65.         self.assertEqual(

  66.             statements[0],

  67.             'ALTER TABLE "BACKENDS_VERYLONGMODELNAME540F" DISABLE CONSTRAINT '

  68.             '"BACKENDS__PERSON_ID_1DD5E829_F" KEEP INDEX;',

  69.         )

  70.         self.assertEqual(

  71.             sorted(statements[1:-1]),

  72.             [

  73.                 'TRUNCATE TABLE "BACKENDS_PERSON";',

  74.                 'TRUNCATE TABLE "BACKENDS_TAG";',

  75.                 'TRUNCATE TABLE "BACKENDS_VERYLONGMODELNAME540F";',

  76.             ],

  77.         )

  78.         self.assertEqual(

  79.             statements[-1],

  80.             'ALTER TABLE "BACKENDS_VERYLONGMODELNAME540F" ENABLE CONSTRAINT '

  81.             '"BACKENDS__PERSON_ID_1DD5E829_F";',

  82.         )

  83. 

  84.     def test_sql_flush_sequences(self):

  85.         statements = connection.ops.sql_flush(

  86.             no_style(),

  87.             [Person._meta.db_table, Tag._meta.db_table],

  88.             reset_sequences=True,

  89.         )

  90.         # The tables and constraints are processed in an unordered set.

  91.         self.assertEqual(

  92.             statements[0],

  93.             'ALTER TABLE "BACKENDS_TAG" DISABLE CONSTRAINT '

  94.             '"BACKENDS__CONTENT_T_FD9D7A85_F" KEEP INDEX;',

  95.         )

  96.         self.assertEqual(

  97.             sorted(statements[1:3]),

  98.             [

  99.                 'TRUNCATE TABLE "BACKENDS_PERSON";',

  100.                 'TRUNCATE TABLE "BACKENDS_TAG";',

  101.             ],

  102.         )

  103.         self.assertEqual(

  104.             statements[3],

  105.             'ALTER TABLE "BACKENDS_TAG" ENABLE CONSTRAINT '

  106.             '"BACKENDS__CONTENT_T_FD9D7A85_F";',

  107.         )

  108.         # Sequences.

  109.         self.assertEqual(len(statements[4:]), 2)

  110.         self.assertIn("BACKENDS_PERSON_SQ", statements[4])

  111.         self.assertIn("BACKENDS_TAG_SQ", statements[5])

  112. 

  113.     def test_sql_flush_sequences_allow_cascade(self):

  114.         statements = connection.ops.sql_flush(

  115.             no_style(),

  116.             [Person._meta.db_table, Tag._meta.db_table],

  117.             reset_sequences=True,

  118.             allow_cascade=True,

  119.         )

  120.         # The tables and constraints are processed in an unordered set.

  121.         self.assertEqual(

  122.             statements[0],

  123.             'ALTER TABLE "BACKENDS_VERYLONGMODELNAME540F" DISABLE CONSTRAINT '

  124.             '"BACKENDS__PERSON_ID_1DD5E829_F" KEEP INDEX;',

  125.         )

  126.         self.assertEqual(

  127.             sorted(statements[1:4]),

  128.             [

  129.                 'TRUNCATE TABLE "BACKENDS_PERSON";',

  130.                 'TRUNCATE TABLE "BACKENDS_TAG";',

  131.                 'TRUNCATE TABLE "BACKENDS_VERYLONGMODELNAME540F";',

  132.             ],

  133.         )

  134.         self.assertEqual(

  135.             statements[4],

  136.             'ALTER TABLE "BACKENDS_VERYLONGMODELNAME540F" ENABLE CONSTRAINT '

  137.             '"BACKENDS__PERSON_ID_1DD5E829_F";',

  138.         )

  139.         # Sequences.

  140.         self.assertEqual(len(statements[5:]), 3)

  141.         self.assertIn("BACKENDS_PERSON_SQ", statements[5])

  142.         self.assertIn("BACKENDS_VERYLONGMODELN7BE2_SQ", statements[6])

  143.         self.assertIn("BACKENDS_TAG_SQ", statements[7])
About Sign Up Leave Feedback Contact