1. from django.db import migrations, models
    
  2. 
    
  3. from ..fields import (
    
  4.     ArrayField,
    
  5.     BigIntegerRangeField,
    
  6.     CICharField,
    
  7.     CIEmailField,
    
  8.     CITextField,
    
  9.     DateRangeField,
    
  10.     DateTimeRangeField,
    
  11.     DecimalRangeField,
    
  12.     EnumField,
    
  13.     HStoreField,
    
  14.     IntegerRangeField,
    
  15.     SearchVectorField,
    
  16. )
    
  17. from ..models import TagField
    
  18. 
    
  19. 
    
  20. class Migration(migrations.Migration):
    
  21.     dependencies = [
    
  22.         ("postgres_tests", "0001_setup_extensions"),
    
  23.     ]
    
  24. 
    
  25.     operations = [
    
  26.         migrations.CreateModel(
    
  27.             name="CharArrayModel",
    
  28.             fields=[
    
  29.                 (
    
  30.                     "id",
    
  31.                     models.AutoField(
    
  32.                         verbose_name="ID",
    
  33.                         serialize=False,
    
  34.                         auto_created=True,
    
  35.                         primary_key=True,
    
  36.                     ),
    
  37.                 ),
    
  38.                 ("field", ArrayField(models.CharField(max_length=10), size=None)),
    
  39.             ],
    
  40.             options={
    
  41.                 "required_db_vendor": "postgresql",
    
  42.             },
    
  43.             bases=(models.Model,),
    
  44.         ),
    
  45.         migrations.CreateModel(
    
  46.             name="DateTimeArrayModel",
    
  47.             fields=[
    
  48.                 (
    
  49.                     "id",
    
  50.                     models.AutoField(
    
  51.                         verbose_name="ID",
    
  52.                         serialize=False,
    
  53.                         auto_created=True,
    
  54.                         primary_key=True,
    
  55.                     ),
    
  56.                 ),
    
  57.                 ("datetimes", ArrayField(models.DateTimeField(), size=None)),
    
  58.                 ("dates", ArrayField(models.DateField(), size=None)),
    
  59.                 ("times", ArrayField(models.TimeField(), size=None)),
    
  60.             ],
    
  61.             options={
    
  62.                 "required_db_vendor": "postgresql",
    
  63.             },
    
  64.             bases=(models.Model,),
    
  65.         ),
    
  66.         migrations.CreateModel(
    
  67.             name="HStoreModel",
    
  68.             fields=[
    
  69.                 (
    
  70.                     "id",
    
  71.                     models.AutoField(
    
  72.                         verbose_name="ID",
    
  73.                         serialize=False,
    
  74.                         auto_created=True,
    
  75.                         primary_key=True,
    
  76.                     ),
    
  77.                 ),
    
  78.                 ("field", HStoreField(blank=True, null=True)),
    
  79.                 ("array_field", ArrayField(HStoreField(), null=True)),
    
  80.             ],
    
  81.             options={
    
  82.                 "required_db_vendor": "postgresql",
    
  83.             },
    
  84.             bases=(models.Model,),
    
  85.         ),
    
  86.         migrations.CreateModel(
    
  87.             name="OtherTypesArrayModel",
    
  88.             fields=[
    
  89.                 (
    
  90.                     "id",
    
  91.                     models.AutoField(
    
  92.                         verbose_name="ID",
    
  93.                         serialize=False,
    
  94.                         auto_created=True,
    
  95.                         primary_key=True,
    
  96.                     ),
    
  97.                 ),
    
  98.                 (
    
  99.                     "ips",
    
  100.                     ArrayField(models.GenericIPAddressField(), size=None, default=list),
    
  101.                 ),
    
  102.                 ("uuids", ArrayField(models.UUIDField(), size=None, default=list)),
    
  103.                 (
    
  104.                     "decimals",
    
  105.                     ArrayField(
    
  106.                         models.DecimalField(max_digits=5, decimal_places=2),
    
  107.                         size=None,
    
  108.                         default=list,
    
  109.                     ),
    
  110.                 ),
    
  111.                 ("tags", ArrayField(TagField(), blank=True, null=True, size=None)),
    
  112.                 (
    
  113.                     "json",
    
  114.                     ArrayField(models.JSONField(default=dict), default=list, size=None),
    
  115.                 ),
    
  116.                 ("int_ranges", ArrayField(IntegerRangeField(), null=True, blank=True)),
    
  117.                 (
    
  118.                     "bigint_ranges",
    
  119.                     ArrayField(BigIntegerRangeField(), null=True, blank=True),
    
  120.                 ),
    
  121.             ],
    
  122.             options={
    
  123.                 "required_db_vendor": "postgresql",
    
  124.             },
    
  125.             bases=(models.Model,),
    
  126.         ),
    
  127.         migrations.CreateModel(
    
  128.             name="IntegerArrayModel",
    
  129.             fields=[
    
  130.                 (
    
  131.                     "id",
    
  132.                     models.AutoField(
    
  133.                         verbose_name="ID",
    
  134.                         serialize=False,
    
  135.                         auto_created=True,
    
  136.                         primary_key=True,
    
  137.                     ),
    
  138.                 ),
    
  139.                 (
    
  140.                     "field",
    
  141.                     ArrayField(
    
  142.                         models.IntegerField(), blank=True, default=list, size=None
    
  143.                     ),
    
  144.                 ),
    
  145.             ],
    
  146.             options={
    
  147.                 "required_db_vendor": "postgresql",
    
  148.             },
    
  149.             bases=(models.Model,),
    
  150.         ),
    
  151.         migrations.CreateModel(
    
  152.             name="NestedIntegerArrayModel",
    
  153.             fields=[
    
  154.                 (
    
  155.                     "id",
    
  156.                     models.AutoField(
    
  157.                         verbose_name="ID",
    
  158.                         serialize=False,
    
  159.                         auto_created=True,
    
  160.                         primary_key=True,
    
  161.                     ),
    
  162.                 ),
    
  163.                 (
    
  164.                     "field",
    
  165.                     ArrayField(ArrayField(models.IntegerField(), size=None), size=None),
    
  166.                 ),
    
  167.             ],
    
  168.             options={
    
  169.                 "required_db_vendor": "postgresql",
    
  170.             },
    
  171.             bases=(models.Model,),
    
  172.         ),
    
  173.         migrations.CreateModel(
    
  174.             name="NullableIntegerArrayModel",
    
  175.             fields=[
    
  176.                 (
    
  177.                     "id",
    
  178.                     models.AutoField(
    
  179.                         verbose_name="ID",
    
  180.                         serialize=False,
    
  181.                         auto_created=True,
    
  182.                         primary_key=True,
    
  183.                     ),
    
  184.                 ),
    
  185.                 (
    
  186.                     "field",
    
  187.                     ArrayField(models.IntegerField(), size=None, null=True, blank=True),
    
  188.                 ),
    
  189.                 (
    
  190.                     "field_nested",
    
  191.                     ArrayField(
    
  192.                         ArrayField(models.IntegerField(null=True), size=None),
    
  193.                         size=None,
    
  194.                         null=True,
    
  195.                     ),
    
  196.                 ),
    
  197.                 ("order", models.IntegerField(null=True)),
    
  198.             ],
    
  199.             options={
    
  200.                 "required_db_vendor": "postgresql",
    
  201.             },
    
  202.             bases=(models.Model,),
    
  203.         ),
    
  204.         migrations.CreateModel(
    
  205.             name="CharFieldModel",
    
  206.             fields=[
    
  207.                 (
    
  208.                     "id",
    
  209.                     models.AutoField(
    
  210.                         verbose_name="ID",
    
  211.                         serialize=False,
    
  212.                         auto_created=True,
    
  213.                         primary_key=True,
    
  214.                     ),
    
  215.                 ),
    
  216.                 ("field", models.CharField(max_length=64)),
    
  217.             ],
    
  218.             options=None,
    
  219.             bases=None,
    
  220.         ),
    
  221.         migrations.CreateModel(
    
  222.             name="TextFieldModel",
    
  223.             fields=[
    
  224.                 (
    
  225.                     "id",
    
  226.                     models.AutoField(
    
  227.                         verbose_name="ID",
    
  228.                         serialize=False,
    
  229.                         auto_created=True,
    
  230.                         primary_key=True,
    
  231.                     ),
    
  232.                 ),
    
  233.                 ("field", models.TextField()),
    
  234.             ],
    
  235.             options=None,
    
  236.             bases=None,
    
  237.         ),
    
  238.         migrations.CreateModel(
    
  239.             name="SmallAutoFieldModel",
    
  240.             fields=[
    
  241.                 (
    
  242.                     "id",
    
  243.                     models.SmallAutoField(serialize=False, primary_key=True),
    
  244.                 ),
    
  245.             ],
    
  246.             options=None,
    
  247.         ),
    
  248.         migrations.CreateModel(
    
  249.             name="BigAutoFieldModel",
    
  250.             fields=[
    
  251.                 (
    
  252.                     "id",
    
  253.                     models.BigAutoField(serialize=False, primary_key=True),
    
  254.                 ),
    
  255.             ],
    
  256.             options=None,
    
  257.         ),
    
  258.         migrations.CreateModel(
    
  259.             name="Scene",
    
  260.             fields=[
    
  261.                 (
    
  262.                     "id",
    
  263.                     models.AutoField(
    
  264.                         verbose_name="ID",
    
  265.                         serialize=False,
    
  266.                         auto_created=True,
    
  267.                         primary_key=True,
    
  268.                     ),
    
  269.                 ),
    
  270.                 ("scene", models.TextField()),
    
  271.                 ("setting", models.CharField(max_length=255)),
    
  272.             ],
    
  273.             options=None,
    
  274.             bases=None,
    
  275.         ),
    
  276.         migrations.CreateModel(
    
  277.             name="Character",
    
  278.             fields=[
    
  279.                 (
    
  280.                     "id",
    
  281.                     models.AutoField(
    
  282.                         verbose_name="ID",
    
  283.                         serialize=False,
    
  284.                         auto_created=True,
    
  285.                         primary_key=True,
    
  286.                     ),
    
  287.                 ),
    
  288.                 ("name", models.CharField(max_length=255)),
    
  289.             ],
    
  290.             options=None,
    
  291.             bases=None,
    
  292.         ),
    
  293.         migrations.CreateModel(
    
  294.             name="CITestModel",
    
  295.             fields=[
    
  296.                 (
    
  297.                     "name",
    
  298.                     CICharField(primary_key=True, serialize=False, max_length=255),
    
  299.                 ),
    
  300.                 ("email", CIEmailField()),
    
  301.                 ("description", CITextField()),
    
  302.                 ("array_field", ArrayField(CITextField(), null=True)),
    
  303.             ],
    
  304.             options={
    
  305.                 "required_db_vendor": "postgresql",
    
  306.             },
    
  307.             bases=None,
    
  308.         ),
    
  309.         migrations.CreateModel(
    
  310.             name="Line",
    
  311.             fields=[
    
  312.                 (
    
  313.                     "id",
    
  314.                     models.AutoField(
    
  315.                         verbose_name="ID",
    
  316.                         serialize=False,
    
  317.                         auto_created=True,
    
  318.                         primary_key=True,
    
  319.                     ),
    
  320.                 ),
    
  321.                 (
    
  322.                     "scene",
    
  323.                     models.ForeignKey("postgres_tests.Scene", on_delete=models.CASCADE),
    
  324.                 ),
    
  325.                 (
    
  326.                     "character",
    
  327.                     models.ForeignKey(
    
  328.                         "postgres_tests.Character", on_delete=models.CASCADE
    
  329.                     ),
    
  330.                 ),
    
  331.                 ("dialogue", models.TextField(blank=True, null=True)),
    
  332.                 ("dialogue_search_vector", SearchVectorField(blank=True, null=True)),
    
  333.                 (
    
  334.                     "dialogue_config",
    
  335.                     models.CharField(max_length=100, blank=True, null=True),
    
  336.                 ),
    
  337.             ],
    
  338.             options={
    
  339.                 "required_db_vendor": "postgresql",
    
  340.             },
    
  341.             bases=None,
    
  342.         ),
    
  343.         migrations.CreateModel(
    
  344.             name="LineSavedSearch",
    
  345.             fields=[
    
  346.                 (
    
  347.                     "id",
    
  348.                     models.AutoField(
    
  349.                         verbose_name="ID",
    
  350.                         serialize=False,
    
  351.                         auto_created=True,
    
  352.                         primary_key=True,
    
  353.                     ),
    
  354.                 ),
    
  355.                 (
    
  356.                     "line",
    
  357.                     models.ForeignKey("postgres_tests.Line", on_delete=models.CASCADE),
    
  358.                 ),
    
  359.                 ("query", models.CharField(max_length=100)),
    
  360.             ],
    
  361.             options={
    
  362.                 "required_db_vendor": "postgresql",
    
  363.             },
    
  364.         ),
    
  365.         migrations.CreateModel(
    
  366.             name="AggregateTestModel",
    
  367.             fields=[
    
  368.                 (
    
  369.                     "id",
    
  370.                     models.AutoField(
    
  371.                         verbose_name="ID",
    
  372.                         serialize=False,
    
  373.                         auto_created=True,
    
  374.                         primary_key=True,
    
  375.                     ),
    
  376.                 ),
    
  377.                 ("boolean_field", models.BooleanField(null=True)),
    
  378.                 ("char_field", models.CharField(max_length=30, blank=True)),
    
  379.                 ("text_field", models.TextField(blank=True)),
    
  380.                 ("integer_field", models.IntegerField(null=True)),
    
  381.                 ("json_field", models.JSONField(null=True)),
    
  382.             ],
    
  383.             options={
    
  384.                 "required_db_vendor": "postgresql",
    
  385.             },
    
  386.         ),
    
  387.         migrations.CreateModel(
    
  388.             name="StatTestModel",
    
  389.             fields=[
    
  390.                 (
    
  391.                     "id",
    
  392.                     models.AutoField(
    
  393.                         verbose_name="ID",
    
  394.                         serialize=False,
    
  395.                         auto_created=True,
    
  396.                         primary_key=True,
    
  397.                     ),
    
  398.                 ),
    
  399.                 ("int1", models.IntegerField()),
    
  400.                 ("int2", models.IntegerField()),
    
  401.                 (
    
  402.                     "related_field",
    
  403.                     models.ForeignKey(
    
  404.                         "postgres_tests.AggregateTestModel",
    
  405.                         models.SET_NULL,
    
  406.                         null=True,
    
  407.                     ),
    
  408.                 ),
    
  409.             ],
    
  410.             options={
    
  411.                 "required_db_vendor": "postgresql",
    
  412.             },
    
  413.         ),
    
  414.         migrations.CreateModel(
    
  415.             name="NowTestModel",
    
  416.             fields=[
    
  417.                 (
    
  418.                     "id",
    
  419.                     models.AutoField(
    
  420.                         verbose_name="ID",
    
  421.                         serialize=False,
    
  422.                         auto_created=True,
    
  423.                         primary_key=True,
    
  424.                     ),
    
  425.                 ),
    
  426.                 ("when", models.DateTimeField(null=True, default=None)),
    
  427.             ],
    
  428.         ),
    
  429.         migrations.CreateModel(
    
  430.             name="UUIDTestModel",
    
  431.             fields=[
    
  432.                 (
    
  433.                     "id",
    
  434.                     models.AutoField(
    
  435.                         verbose_name="ID",
    
  436.                         serialize=False,
    
  437.                         auto_created=True,
    
  438.                         primary_key=True,
    
  439.                     ),
    
  440.                 ),
    
  441.                 ("uuid", models.UUIDField(default=None, null=True)),
    
  442.             ],
    
  443.         ),
    
  444.         migrations.CreateModel(
    
  445.             name="RangesModel",
    
  446.             fields=[
    
  447.                 (
    
  448.                     "id",
    
  449.                     models.AutoField(
    
  450.                         verbose_name="ID",
    
  451.                         serialize=False,
    
  452.                         auto_created=True,
    
  453.                         primary_key=True,
    
  454.                     ),
    
  455.                 ),
    
  456.                 ("ints", IntegerRangeField(null=True, blank=True)),
    
  457.                 ("bigints", BigIntegerRangeField(null=True, blank=True)),
    
  458.                 ("decimals", DecimalRangeField(null=True, blank=True)),
    
  459.                 ("timestamps", DateTimeRangeField(null=True, blank=True)),
    
  460.                 ("timestamps_inner", DateTimeRangeField(null=True, blank=True)),
    
  461.                 (
    
  462.                     "timestamps_closed_bounds",
    
  463.                     DateTimeRangeField(null=True, blank=True, default_bounds="[]"),
    
  464.                 ),
    
  465.                 ("dates", DateRangeField(null=True, blank=True)),
    
  466.                 ("dates_inner", DateRangeField(null=True, blank=True)),
    
  467.             ],
    
  468.             options={"required_db_vendor": "postgresql"},
    
  469.             bases=(models.Model,),
    
  470.         ),
    
  471.         migrations.CreateModel(
    
  472.             name="RangeLookupsModel",
    
  473.             fields=[
    
  474.                 (
    
  475.                     "id",
    
  476.                     models.AutoField(
    
  477.                         verbose_name="ID",
    
  478.                         serialize=False,
    
  479.                         auto_created=True,
    
  480.                         primary_key=True,
    
  481.                     ),
    
  482.                 ),
    
  483.                 (
    
  484.                     "parent",
    
  485.                     models.ForeignKey(
    
  486.                         "postgres_tests.RangesModel",
    
  487.                         models.SET_NULL,
    
  488.                         blank=True,
    
  489.                         null=True,
    
  490.                     ),
    
  491.                 ),
    
  492.                 ("integer", models.IntegerField(blank=True, null=True)),
    
  493.                 ("big_integer", models.BigIntegerField(blank=True, null=True)),
    
  494.                 ("float", models.FloatField(blank=True, null=True)),
    
  495.                 ("timestamp", models.DateTimeField(blank=True, null=True)),
    
  496.                 ("date", models.DateField(blank=True, null=True)),
    
  497.                 ("small_integer", models.SmallIntegerField(blank=True, null=True)),
    
  498.                 (
    
  499.                     "decimal_field",
    
  500.                     models.DecimalField(
    
  501.                         max_digits=5, decimal_places=2, blank=True, null=True
    
  502.                     ),
    
  503.                 ),
    
  504.             ],
    
  505.             options={
    
  506.                 "required_db_vendor": "postgresql",
    
  507.             },
    
  508.             bases=(models.Model,),
    
  509.         ),
    
  510.         migrations.CreateModel(
    
  511.             name="ArrayEnumModel",
    
  512.             fields=[
    
  513.                 (
    
  514.                     "id",
    
  515.                     models.AutoField(
    
  516.                         verbose_name="ID",
    
  517.                         serialize=False,
    
  518.                         auto_created=True,
    
  519.                         primary_key=True,
    
  520.                     ),
    
  521.                 ),
    
  522.                 (
    
  523.                     "array_of_enums",
    
  524.                     ArrayField(EnumField(max_length=20), size=None),
    
  525.                 ),
    
  526.             ],
    
  527.             options={
    
  528.                 "required_db_vendor": "postgresql",
    
  529.             },
    
  530.             bases=(models.Model,),
    
  531.         ),
    
  532.         migrations.CreateModel(
    
  533.             name="Room",
    
  534.             fields=[
    
  535.                 (
    
  536.                     "id",
    
  537.                     models.AutoField(
    
  538.                         verbose_name="ID",
    
  539.                         serialize=False,
    
  540.                         auto_created=True,
    
  541.                         primary_key=True,
    
  542.                     ),
    
  543.                 ),
    
  544.                 ("number", models.IntegerField(unique=True)),
    
  545.             ],
    
  546.         ),
    
  547.         migrations.CreateModel(
    
  548.             name="HotelReservation",
    
  549.             fields=[
    
  550.                 (
    
  551.                     "id",
    
  552.                     models.AutoField(
    
  553.                         verbose_name="ID",
    
  554.                         serialize=False,
    
  555.                         auto_created=True,
    
  556.                         primary_key=True,
    
  557.                     ),
    
  558.                 ),
    
  559.                 ("room", models.ForeignKey("postgres_tests.Room", models.CASCADE)),
    
  560.                 ("datespan", DateRangeField()),
    
  561.                 ("start", models.DateTimeField()),
    
  562.                 ("end", models.DateTimeField()),
    
  563.                 ("cancelled", models.BooleanField(default=False)),
    
  564.                 ("requirements", models.JSONField(blank=True, null=True)),
    
  565.             ],
    
  566.             options={
    
  567.                 "required_db_vendor": "postgresql",
    
  568.             },
    
  569.         ),
    
  570.     ]