django-postpone-index 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

{django_postpone_index-0.0.1.dist-info → django_postpone_index-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-postpone-index
-Version: 0.0.1
+Version: 0.0.3
 Summary: Postpone index creation to provide Zero Downtime Migration feature
 Home-page: https://github.com/nnseva/django-postpone-index
 Author: Vsevolod Novikov
@@ -169,6 +169,43 @@ calling the `apply_postponed` migration command again. All not-applied indexes w
 **NOTICE** the `apply_postponed` management command doesn't have any explicit locking mechanics. Avoid starting this
 command concurrently with itself or another `migrate` command on the same database.
 
+## Intermediate migration state
+
+Apart from standard Django migrations, using the `postpone_index` package leads to the *intermediate migration state*
+after the `migrate` management command finished:
+
+- new model structure is applied
+- indexes to be deleted are deleted
+- indexes to be created are *not created yet*
+
+You should be aware that if you introduce a new unique index or constraint, the database does not control uniqueness
+based on not yet created indexes at this time.
+
+Your code works now as expected everywhere, except the code which is based on new unique constraints introduced in applied migrations.
+
+Apply the `apply_postponed run` management command to make these new indexes work.
+
+Any error while `apply_postponed run` execution is stored in the `PostponedSQL` model instance.
+
+You can see erroneous lines using `apply_postponed list` command. See the `[E]` mark at the start of the line.
+
+You also can see the error details using the format parameter of the `apply_postponed list -f '... %(error)s'` management command.
+
+The `apply_postponed run -x` breaks execution on any error. You can see the error in the standard error or logging streams.
+
+The `apply_postponed run` (without `-x` parameter) doesn't stop on error, but outputs warning to the log stream instead.
+
+When the error happened, it most probably is caused by the non-unique records. Fix the data and try to execute
+`apply_postponed run` again to create an index.
+
+After the successfull `apply_postponed run` execution, the migration state is finalised to be equal as if you applied the migration
+without `postpone_index` package at all.
+
+The `apply_postponed run` management command marks all successfully executed `PostponedSQL` instances as `done`. You can see `[X]` mark
+at the start of the line produced by `apply_ponsponed list` management command.
+
+You can cleanup `done` instances using `apply_postponed cleanup` management command. This step is optional.
+
 ## Django testing
 
 Django migrates testing database before tests. Always use `POSTPONE_INDEX_IGNORE = True` settings to avoid postpone index

django_postpone_index-0.0.3.dist-info/RECORD

@@ -0,0 +1,23 @@
+postpone_index/__init__.py,sha256=s1NgdtOn7SO7scs-uAaq1134F7Luh-JjB5Ghra3D2fQ,84
+postpone_index/_version.py,sha256=pBZsQt6tlL02W-ri--X_4JCubpAK7jjCSnOmUp_isjc,704
+postpone_index/admin.py,sha256=TAZxaciQkEBNhReYulsU5VopPCyABtMLZvCSxk0CfYE,820
+postpone_index/apps.py,sha256=1ap2HY49uXVXjY9UWK3___fjPe22wqFOSOnuH2kIAxs,200
+postpone_index/migration_utils.py,sha256=02rm77mz_MAufl5vdqKPV1CAd1-3bRk6kSy4MIxKsEo,752
+postpone_index/models.py,sha256=Aeow27GSHCkklLnUAGnRwwaCaLrQ11b2Sg7vIZIybGg,3580
+postpone_index/testing_utils.py,sha256=ycxp7ovY6JceOvNpotK7OGAebhdHicXJ-0fWJmaq9fo,1224
+postpone_index/utils.py,sha256=wYVPsQRs3LN-ZtvfSWrDDqFFp0OCkVxW9j7w9yqd47o,3823
+postpone_index/contrib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postpone_index/contrib/postgis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postpone_index/contrib/postgis/base.py,sha256=a5h1k11BVSOflSSesTxObKAEYNWtisFLRbApzHeW3c0,289
+postpone_index/contrib/postgis/schema.py,sha256=eantuNhFYWDngDnAeURJurpW58UztPnjTIySmUlXx7s,340
+postpone_index/contrib/postgres/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postpone_index/contrib/postgres/base.py,sha256=Xq90nJkxGSgR8Im9JPnFepeMb0-bur9sRjPpm3zMd6U,281
+postpone_index/contrib/postgres/schema.py,sha256=qmJRxBCKfwWVrM7P2vSaaR4aAl_C6-2qMrKPiQQ9QpU,10383
+postpone_index/management/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postpone_index/management/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+postpone_index/management/commands/apply_postponed.py,sha256=wVbw0ugUyPuYwUikGnn5MvP9l9OsEIZja9sb6nsMtOw,9107
+postpone_index/sql/start.sql,sha256=44yFbZTjknjXUvl7MpO1uuPv-CVBsZcnUDuKc8mVj3k,871
+django_postpone_index-0.0.3.dist-info/METADATA,sha256=aEo4ieeQpm90WE2j8ljOuz_F3m5pD1e0wzGBTBA4MIQ,12365
+django_postpone_index-0.0.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+django_postpone_index-0.0.3.dist-info/top_level.txt,sha256=B6q_TICqApvruf_NJfnLFNLZLpxMLebQF6cPdKrWm5A,162
+django_postpone_index-0.0.3.dist-info/RECORD,,

django_postpone_index-0.0.3.dist-info/top_level.txt

@@ -0,0 +1,6 @@
+postpone_index
+postpone_index/contrib
+postpone_index/contrib/postgis
+postpone_index/contrib/postgres
+postpone_index/management
+postpone_index/management/commands

postpone_index/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.1'
-__version_tuple__ = version_tuple = (0, 0, 1)
+__version__ = version = '0.0.3'
+__version_tuple__ = version_tuple = (0, 0, 3)
 
 __commit_id__ = commit_id = None

postpone_index/contrib/postgis/base.py

@@ -0,0 +1,11 @@
+from django.contrib.gis.db.backends.postgis.base import (
+    DatabaseWrapper as _DatabaseWrapper,
+)
+
+from postpone_index.contrib.postgis.schema import DatabaseSchemaEditor
+
+
+class DatabaseWrapper(_DatabaseWrapper):
+    """Database wrapper"""
+
+    SchemaEditorClass = DatabaseSchemaEditor

postpone_index/contrib/postgis/schema.py

@@ -0,0 +1,11 @@
+"""Schema editor with concurrent index creation support."""
+
+from django.contrib.gis.db.backends.postgis.schema import (
+    PostGISSchemaEditor as _DatabaseSchemaEditor,
+)
+
+from postpone_index.contrib.postgres.schema import DatabaseSchemaEditorMixin
+
+
+class DatabaseSchemaEditor(DatabaseSchemaEditorMixin, _DatabaseSchemaEditor):
+    pass

postpone_index/contrib/postgres/base.py

@@ -0,0 +1,11 @@
+from django.db.backends.postgresql.base import (
+    DatabaseWrapper as _DatabaseWrapper,
+)
+
+from postpone_index.contrib.postgres.schema import DatabaseSchemaEditor
+
+
+class DatabaseWrapper(_DatabaseWrapper):
+    """Database wrapper"""
+
+    SchemaEditorClass = DatabaseSchemaEditor

postpone_index/contrib/postgres/schema.py

@@ -0,0 +1,220 @@
+"""Schema editor with concurrent index creation support."""
+import logging
+import os
+import os.path
+
+from django.conf import settings
+from django.db.backends.postgresql.schema import (
+    DatabaseSchemaEditor as _DatabaseSchemaEditor,
+)
+
+from postpone_index.utils import Utils
+
+
+logger = logging.getLogger(__name__)
+package_folder = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
+
+
+class DatabaseSchemaEditorMixin(Utils):
+    """Mixin to embed into DatabaseSchemaEditor"""
+    _base_tables_created = False
+
+    def _create_base_tables(self):
+        """
+        Create base package tables on the first access to this function
+        """
+        if self._base_tables_created:
+            return
+        # Avoid circular import
+        from postpone_index.models import PostponedSQL
+
+        PostponedSQL.objects.using(self.connection.alias)._create_base_tables()
+        self._base_tables_created = True
+
+    def _ignore(self):
+        """Check whether to ignore the extension"""
+        return getattr(settings, 'POSTPONE_INDEX_IGNORE', False) or getattr(self, '_postpone_index_ignore', False)
+
+    def execute(self, sql, params=()):
+        """
+        Overriden for execute processing with special handling for index operations.
+
+        All indexing operations are postponed by writing to a special table instead of execution.
+
+        They will be executed later in CONCURRENTLY manner.
+        """
+        if self._ignore():
+            return super().execute(sql, params)
+
+        self._create_base_tables()
+
+        # Avoid circular import
+        from postpone_index.models import PostponedSQL
+
+        if match := self._create_index_re.fullmatch(str(sql)):
+            # Postpone index creation
+            index_name = match.group('index_nameq') or match.group('index_name')
+            table_name = match.group('table_nameq') or match.group('table_name')
+            columns = ','.join(self._extract_column_names(match.group('rest')))
+            description = 'Create Index "%s" on "%s" (%s)' % (
+                index_name,
+                table_name,
+                columns
+            )
+            PostponedSQL.objects.using(self.connection.alias).create(
+                sql=str(sql),
+                description=description,
+                table=table_name,
+                db_index=index_name,
+                fields=columns
+            )
+            logger.info('[%s] Postponed %s', self.connection.alias, description)
+        elif match := self._add_constraint_re.fullmatch(str(sql)):
+            # Postpone constraint creation
+            index_name = match.group('index_nameq') or match.group('index_name')
+            table_name = match.group('table_nameq') or match.group('table_name')
+            columns = ','.join(self._extract_column_names(match.group('rest')))
+            description = 'Add Unique Constraint "%s" on "%s" (%s)' % (
+                index_name,
+                table_name,
+                columns,
+            )
+            PostponedSQL.objects.using(self.connection.alias).create(
+                sql=str(sql),
+                description=description,
+                table=table_name,
+                db_index=index_name,
+                fields=columns
+            )
+            logger.info('[%s] Postponed %s', self.connection.alias, description)
+        else:
+            if match := self._drop_index_re.fullmatch(str(sql)):
+                # Override to ignore inexistent index drop error
+                index_name = match.group('index_nameq') or match.group('index_name')
+                if PostponedSQL.objects.using(self.connection.alias).filter(db_index=index_name, done=False).delete()[0]:
+                    logger.info('[%s] Removed Index %s from postponed', self.connection.alias, index_name)
+                # Avoid errors on introspecting inexistent index
+                try:
+                    return super().execute(sql, params)
+                    logger.info('[%s] Drop index %s success', self.connection.alias, index_name)
+                except Exception as ex:
+                    logger.info('[%s] Drop index %s ignored: %s', self.connection.alias, index_name, ex)
+            elif match := self._drop_constraint_re.fullmatch(str(sql)):
+                # Override to ignore inexistent constraint drop error
+                index_name = match.group('index_nameq') or match.group('index_name')
+                table_name = match.group('table_nameq') or match.group('table_name')
+                if PostponedSQL.objects.using(self.connection.alias).filter(db_index=index_name, table=table_name, done=False).delete()[0]:
+                    logger.info('[%s] Removed Constraint %s on %s from postponed', self.connection.alias, index_name, table_name)
+                # Avoid errors on introspecting inexistent constraint
+                try:
+                    return super().execute(sql, params)
+                    logger.info('[%s] Drop constraint %s success', self.connection.alias, index_name)
+                except Exception as ex:
+                    logger.info('[%s] Drop constraint %s ignored: %s', self.connection.alias, index_name, ex)
+            elif match := self._drop_table_re.fullmatch(str(sql)):
+                # Table dropped cancels all postponed operations related
+                table_name = match.group('table_nameq') or match.group('table_name')
+                if PostponedSQL.objects.using(self.connection.alias).filter(table=table_name, done=False).delete()[0]:
+                    logger.info('[%s] Removed all indexes on table %s from postponed', self.connection.alias, table_name)
+                return super().execute(sql, params)
+            elif match := self._drop_column_re.fullmatch(str(sql)):
+                # Table dropped cancels all postponed operations related
+                table_name = match.group('table_nameq') or match.group('table_name')
+                column_name = match.group('column_nameq') or match.group('column_name')
+                if PostponedSQL.objects.using(self.connection.alias).filter(
+                    table=table_name, fields__contains='"%s"' % column_name, done=False
+                ).delete()[0]:
+                    logger.info(
+                        '[%s] Removed all indexes on column %s of table %s from postponed',
+                        self.connection.alias, column_name, table_name
+                    )
+                return super().execute(sql, params)
+            else:
+                logger.debug('[%s] No special statements: %s', self.connection.alias, sql)
+                return super().execute(sql, params)
+
+    def _alter_field(
+        self, model, old_field, new_field, old_type, new_type,
+        old_db_params, new_db_params, *args, **kw
+    ):
+        """Overriden for special field attributes processing"""
+
+        # The original code uses database introspection to decide whether the
+        # index to be removed is present. We override the function before the introspection calls
+        # to remove the postponed index creation jobs instead.
+
+        if self._ignore():
+            return super()._alter_field(
+                model, old_field, new_field, old_type, new_type,
+                old_db_params, new_db_params, *args, **kw
+            )
+
+        self._create_base_tables()
+
+        # Avoid circular import
+        from postpone_index.models import PostponedSQL
+
+        suffixes = []
+
+        if old_field.unique and not new_field.unique:
+            # Delete unique field attribute cancels all postponed operations related
+            suffixes.append('_uniq')
+
+        if old_field.db_index and not new_field.db_index:
+            # Delete db_index field attribute cancels all postponed operations related
+            suffixes.append('')
+            suffixes.append('_like')
+
+        if old_db_params['check'] != new_db_params['check'] and old_db_params['check']:
+            # Delete check field attribute cancels all postponed operations related
+            suffixes.append('_check')
+
+        for suffix in suffixes:
+            index_name = self._create_index_name(
+                model._meta.db_table,
+                [old_field.column],
+                suffix
+            )
+            if PostponedSQL.objects.using(self.connection.alias).filter(table=model._meta.db_table, db_index=index_name, done=False).delete()[0]:
+                logger.info('[%s] Removed single index %s on %s from postponed', self.connection.alias, index_name, model._meta.db_table)
+
+        return super()._alter_field(
+            model, old_field, new_field, old_type, new_type,
+            old_db_params, new_db_params, *args, **kw
+        )
+
+    def _delete_composed_index(self, model, fields, constraint_kwargs, sql):
+        """Overriden for special composed index processing"""
+
+        # The original code uses database introspection to decide whether the
+        # index to be removed is present. We override the function before the introspection calls
+        # to remove the postponed index creation jobs instead.
+
+        if self._ignore():
+            return super()._delete_composed_index(model, fields, constraint_kwargs, sql)
+
+        self._create_base_tables()
+
+        # Avoid circular import
+        from postpone_index.models import PostponedSQL
+
+        # Delete composed index cancels all postponed operations related
+        index_name = self._create_index_name(
+            model._meta.db_table,
+            [model._meta.get_field(f).column for f in fields],
+            '_uniq' if (constraint_kwargs or {}).get('unique', False) else '_idx'
+        )
+
+        if PostponedSQL.objects.using(self.connection.alias).filter(table=model._meta.db_table, db_index=index_name, done=False).delete()[0]:
+            logger.info('[%s] Removed composed index %s on %s from postponed', self.connection.alias, index_name, model._meta.db_table)
+
+        # Avoid errors on introspecting inexistent compound index
+        try:
+            super()._delete_composed_index(model, fields, constraint_kwargs, sql)
+            logger.info('[%s] Delete composed %s on %s success', self.connection.alias, index_name, model._meta.db_table)
+        except Exception as ex:
+            logger.info('[%s] Delete composed %s on %s ignored: %s', self.connection.alias, index_name, model._meta.db_table, ex)
+
+
+class DatabaseSchemaEditor(DatabaseSchemaEditorMixin, _DatabaseSchemaEditor):
+    pass

postpone_index/management/commands/apply_postponed.py

@@ -0,0 +1,251 @@
+"""
+The apply_postponed command applies collected postponed index and constraint creation
+in CONCURRENTLY manner.
+"""
+import argparse
+import logging
+import sys
+
+from django.core.management.base import BaseCommand
+from django.db import connections
+
+from postpone_index.models import PostponedSQL
+from postpone_index.utils import ObjMap, Utils
+
+
+logger = logging.getLogger(__name__)
+
+
+class Command(Utils, BaseCommand):
+    __doc__ = __doc__
+    help = __doc__
+
+    _short_format = '%(d)s %(sql)s'
+    _descr_format = '%(i)04d: %(d)s %(description)s'
+    _long_format = '%(i)04d: %(d)s %(sql)s'
+
+    class formatter_class(argparse.RawTextHelpFormatter):
+        pass
+
+    def add_arguments(self, parser):
+        subparsers = parser.add_subparsers(
+            title='Commands',
+            dest='command',
+            help='Use --help with command to see the command-specific help',
+        )
+        show = subparsers.add_parser(
+            name='list',
+            formatter_class=self.formatter_class,
+            help='Show applied and not yet applied postponed index creation jobs'
+        )
+        show.add_argument(
+            '-db', '--database',
+            dest='database',
+            default='default',
+            help='Database alias to be applied, default is %(default)s'
+        )
+        show.add_argument(
+            '-r', '--reversed',
+            dest='reversed',
+            action='store_true',
+            help='Show records in reversed order'
+        )
+        show.add_argument(
+            '-u', '--unapplied',
+            dest='unapplied',
+            action='store_true',
+            help='Show only unapplied records'
+        )
+        show.add_argument(
+            '-e', '--erroneous',
+            dest='erroneous',
+            action='store_true',
+            help='Show only erroneous records having non-null error'
+        )
+        show.add_argument(
+            '-f', '--format',
+            dest='format',
+            default='s',
+            help=f"""Output format. Use either:
+    - `s` for short SQL-only format `{self._short_format}` (default)
+    - `d` for enumerated descriptions format `{self._descr_format}`
+    - `l` for enumerated SQL format `{self._long_format}`
+    - %-style named format
+Use the PostponedSQL field names for %-style format.
+Additional names are:
+    - `i` for enumeration index
+    - `d` for the `done` attribute in form of `+` or `-`""".replace('%', '%%')
+        )
+        run = subparsers.add_parser(
+            name='run',
+            formatter_class=self.formatter_class,
+            help='Apply not yet applied postponed index creation jobs'
+        )
+        run.add_argument(
+            '-x', '--exception',
+            dest='exception',
+            action='store_true',
+            help='Immediately stop on any exception. Continues with the next job by default'
+        )
+        run.add_argument(
+            '-db', '--database',
+            dest='database',
+            default='default',
+            help='Database alias to be applied, default is %(default)s'
+        )
+        cleanup = subparsers.add_parser(
+            name='cleanup',
+            formatter_class=self.formatter_class,
+            help='Cleanup stored applied index creation jobs'
+        )
+        cleanup.add_argument(
+            '--all',
+            dest='all',
+            action='store_true',
+            help='Cleanup all postponed SQL including not yet applied. Be careful!'
+        )
+        cleanup.add_argument(
+            '-db', '--database',
+            dest='database',
+            default='default',
+            help='Database alias to be applied, default is %(default)s'
+        )
+
+    def handle(self, *args, **options):
+        """Handling commands"""
+        if not options['command']:
+            return self.print_help(sys.argv[0], sys.argv[1])
+        return getattr(self, '_handle_%s' % options['command'])(*args, **options)
+
+    def _handle_list(self, *args, **options):
+        """Handle list command"""
+        try:
+            PostponedSQL.objects.using(options['database']).all().first()
+        except Exception:
+            # The table has not been created
+            return
+
+        q = PostponedSQL.objects.using(options['database']).all()
+        q = q.order_by('-ts' if options['reversed'] else 'ts')
+        if options['unapplied']:
+            q = q.filter(done=False)
+        if options['erroneous']:
+            q = q.filter(error__isnull=False)
+        match options['format']:
+            case 's':
+                format = self._short_format
+            case 'd':
+                format = self._descr_format
+            case 'l':
+                format = self._long_format
+            case _:
+                format = options['format']
+        for i, j in enumerate(q):
+            print(format % ObjMap(j, {
+                'i': i,
+            }))
+
+    def _handle_run(self, *args, **options):
+        """Handle run command"""
+        try:
+            PostponedSQL.objects.using(options['database']).all().first()
+        except Exception:
+            # The table has not been created
+            return
+        q = PostponedSQL.objects.using(options['database']).filter(done=False).order_by('ts')
+        for j in q:
+            try:
+                j.error = None
+                j.done = False
+                self._handle_run_job(j, *args, **options)
+                j.save(update_fields=['error', 'done'])
+            except Exception as ex:
+                logger.warning('Error on running job: %s', ex)
+                if not j.error:
+                    j.error = 'Exception: %s' % ex
+                j.save(update_fields=['error', 'done'])
+                if options['exception']:
+                    raise
+
+    def _handle_cleanup(self, *args, **options):
+        """Handle cleanup command"""
+        try:
+            PostponedSQL.objects.using(options['database']).all().first()
+        except Exception:
+            # The table has not been created
+            return
+        q = PostponedSQL.objects.using(options['database'])
+        if not options['all']:
+            q = q.filter(done=True)
+        q.delete()
+
+    def _handle_run_job(self, job, *args, **options):
+        """Handle a single job for the run command"""
+        if match := self._create_index_re.fullmatch(job.sql):
+            unique = match.group('unique') or ''
+            index_name = match.group('index_nameq') or match.group('index_name')
+            table_name = match.group('table_nameq') or match.group('table_name')
+            rest = match.group('rest')
+            sql = 'DROP INDEX IF EXISTS "%s"' % (
+                index_name,
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+            sql = 'CREATE %sINDEX CONCURRENTLY "%s" ON "%s" %s' % (
+                unique,
+                index_name,
+                table_name,
+                rest
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+        elif match := self._add_constraint_re.fullmatch(job.sql):
+            unique = 'UNIQUE '
+            index_name = match.group('index_nameq') or match.group('index_name')
+            table_name = match.group('table_nameq') or match.group('table_name')
+            rest = match.group('rest')
+            sql = 'ALTER TABLE "%s" DROP CONSTRAINT IF EXISTS "%s"' % (
+                table_name,
+                index_name,
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+            sql = 'DROP INDEX IF EXISTS "%s"' % (
+                index_name,
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+            sql = 'CREATE %sINDEX CONCURRENTLY "%s" ON "%s" %s' % (
+                unique,
+                index_name,
+                table_name,
+                rest
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+            sql = 'ALTER TABLE "%s" ADD CONSTRAINT "%s" UNIQUE USING INDEX "%s"' % (
+                table_name,
+                index_name,
+                index_name,
+            )
+            logger.info('[%s] SQL: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+        else:
+            logger.info('[%s] Unrecognized: %s', options['database'], sql)
+            cursor = connections[options['database']].cursor()
+            cursor.execute(sql)
+            cursor.close()
+        job.error = None
+        job.done = True

postpone_index/models.py

@@ -1,12 +1,78 @@
+import logging
+import os
 import time
 
 from unlimited_char.fields import CharField
 
-from django.db import models
+from django.db import models, connections
 from django.utils.translation import gettext_lazy as _
 
+logger = logging.getLogger(__name__)
+package_folder = os.path.dirname(os.path.abspath(__file__))
+
+
+class PostponedSQLQuerySet(models.QuerySet):
+    """
+    QuerySet for PostponedSQL model.
+
+    Redefined for admin view when table is absent.
+    """
+
+    def _create_base_tables(self):
+        """
+        Create base package table if absent
+        """
+        if self._is_present():
+            logger.debug('[%s] The PostponedSQL storage already exists', self.db)
+            return
+        logger.info('[%s] The PostponedSQL storage is absent, creating', self.db)
+        with open(os.path.join(package_folder, 'sql/start.sql')) as f:
+            sql = f.read()
+        cursor = connections[self.db].cursor()
+        cursor.execute(sql)
+
+    def count(self):
+        """
+        Count only if table is present
+        """
+        if not self._is_present():
+            return 0
+        return super().count()
+
+    def _is_present(self):
+        """
+        Check if table is present
+        """
+        cursor = connections[self.db].cursor()
+        cursor.execute(
+            """
+                SELECT 1 FROM information_schema.tables
+                WHERE table_schema = 'public' AND table_name = '%s' limit 1
+            """ % PostponedSQL._meta.db_table
+        )
+        return bool(cursor.fetchall())
+
+
+class PostponedSQLManager(models.Manager):
+    """
+    Manager for PostponedSQL model.
+
+    Redefined for admin view when table is absent.
+    """
+
+    def get_queryset(self):
+        """
+        Get custom QuerySet
+        """
+        qs = PostponedSQLQuerySet(self.model, using=self._db)
+        if not qs._is_present():
+            return qs.none()
+        return qs
+
 
 class PostponedSQL(models.Model):
+    """Model to store postponed SQL commands"""
+
     ts = models.BigIntegerField(
         primary_key=True, editable=False,
         default=time.time_ns,
@@ -47,6 +113,8 @@ class PostponedSQL(models.Model):
         help_text=_('Last error reported when tried to apply')
     )
 
+    objects = PostponedSQLManager()
+
     @property
     def d(self):
         """Status mark"""

postpone_index/sql/start.sql

@@ -0,0 +1,14 @@
+CREATE TABLE IF NOT EXISTS public.postpone_index_postponedsql (
+    ts bigint NOT NULL PRIMARY KEY,
+    description character varying NOT NULL,
+    "sql" text NOT NULL,
+    "table" character varying,
+    db_index character varying,
+    fields character varying,
+    "done" boolean NOT NULL DEFAULT FALSE,
+    "error" text
+);
+CREATE INDEX IF NOT EXISTS postpone_index_postponedsql_db_index ON public.postpone_index_postponedsql USING btree (db_index);
+CREATE INDEX IF NOT EXISTS postpone_index_postponedsql_db_index_like ON public.postpone_index_postponedsql USING btree (db_index varchar_pattern_ops);
+CREATE INDEX IF NOT EXISTS postpone_index_postponedsql_table ON public.postpone_index_postponedsql USING btree ("table");
+CREATE INDEX IF NOT EXISTS postpone_index_postponedsql_table_like ON public.postpone_index_postponedsql USING btree ("table" varchar_pattern_ops);

django_postpone_index-0.0.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-postpone_index/__init__.py,sha256=s1NgdtOn7SO7scs-uAaq1134F7Luh-JjB5Ghra3D2fQ,84
-postpone_index/_version.py,sha256=qf6R-J7-UyuABBo8c0HgaquJ8bejVbf07HodXgwAwgQ,704
-postpone_index/admin.py,sha256=TAZxaciQkEBNhReYulsU5VopPCyABtMLZvCSxk0CfYE,820
-postpone_index/apps.py,sha256=1ap2HY49uXVXjY9UWK3___fjPe22wqFOSOnuH2kIAxs,200
-postpone_index/migration_utils.py,sha256=02rm77mz_MAufl5vdqKPV1CAd1-3bRk6kSy4MIxKsEo,752
-postpone_index/models.py,sha256=jMsA5hdiL8Xgl-hq7bgVl5NUX6LXlSYpMuX9pD68BbU,1771
-postpone_index/testing_utils.py,sha256=ycxp7ovY6JceOvNpotK7OGAebhdHicXJ-0fWJmaq9fo,1224
-postpone_index/utils.py,sha256=wYVPsQRs3LN-ZtvfSWrDDqFFp0OCkVxW9j7w9yqd47o,3823
-django_postpone_index-0.0.1.dist-info/METADATA,sha256=f6r6FaLnag7wQ4NjfFRPhMDZAffRmXtXK7Bg7o4viLU,10415
-django_postpone_index-0.0.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-django_postpone_index-0.0.1.dist-info/top_level.txt,sha256=SzF44QR8Fr9ArKXZPY7FSJUlTBKYo_dPNHn2hbqKOrc,15
-django_postpone_index-0.0.1.dist-info/RECORD,,

django_postpone_index-0.0.1.dist-info/top_level.txt

@@ -1 +0,0 @@
-postpone_index