Split syncing of views into a separate mgmt command.

Author: scott-w

README.md

@@ -107,3 +107,5 @@ CREATE TABLE myapp_customer (
 CREATE VIEW myapp_preferredcustomer AS
 SELECT * FROM myapp_customer WHERE is_preferred = TRUE;
 ```
+
+To create all your views, run ``python manage.py sync_pgviews``

dev_requirements

@@ -0,0 +1,2 @@
+Django>=1.3
+django-nose>=1.1

django_postgres/management/__init__.py

@@ -0,0 +1,21 @@
+"""Synchronise SQL Views.
+"""
+from django.core.management.base import NoArgsCommand
+from django.db import models
+
+from django_postgres.view import create_views
+
+
+class Command(NoArgsCommand):
+    help = 'Creates and Updates all SQL Views'
+
+    def handle_noargs(self, **options):
+        all_modules = models.get_apps()
+        modules = '\n '.join((m.__name__ for m in all_modules))
+        self.stdout.write(
+            'Creating Views for all modules:\n {modules}\n'.format(
+                modules=modules
+            )
+        )
+        for module in all_modules:
+            create_views(module)

django_postgres/management/commands/__init__.py

@@ -4,7 +4,7 @@
 import copy
 import re
 
-from django.db import connection
+from django.db import connection, transaction
 from django.db import models
 
 
@@ -51,22 +51,26 @@ def realize_deferred_projections(sender, *args, **kwargs):
 models.signals.class_prepared.connect(realize_deferred_projections)
 
 
-def create_views(sender, *args, **kwargs):
+def create_views(models_module, *args, **kwargs):
     """Create the database views after syncdb."""
-    models_module = sender
     for name, view_cls in vars(models_module).iteritems():
         if not (isinstance(view_cls, type) and
                 issubclass(view_cls, View) and
                 hasattr(view_cls, 'sql')):
             continue
-        query = "CREATE OR REPLACE VIEW %s AS %s;" % (view_cls._meta.db_table,
-                                                      view_cls.sql)
+
+        query = 'CREATE OR REPLACE VIEW {table} AS {select};'
+
+        query = query.format(
+            table=view_cls._meta.db_table,
+            select=view_cls.sql)
+
         cursor = connection.cursor()
         try:
             cursor.execute(query)
+            transaction.commit_unless_managed()
         finally:
             cursor.close()
-models.signals.post_syncdb.connect(create_views)
 
 
 def get_fields_by_name(model_cls, *field_names):

django_postgres/management/commands/sync_pgviews.py

@@ -40,8 +40,8 @@ You can create this view by just subclassing :class:`django_postgres.View`. In
   .. attribute:: sql
 
     The SQL for this view (typically a ``SELECT`` query). This attribute is
-    optional, but if present, the view will be created on ``syncdb`` (which is
-    probably what you want).
+    optional, but if present, the view will be created on ``sync_pgviews``
+    (which is probably what you want).
 
   .. attribute:: projection
 
@@ -93,23 +93,13 @@ Or add an ``id`` column to your view's SQL query (this example uses
                  FROM auth_user;"""
 
 
-Migrations
-==========
-
-Views play well with South migrations; just create the view using raw SQL in a
-schema migration:
-
-.. code-block:: bash
+Creating the Views
+==================
 
-    $ ./manage.py schemamigration --empty myapp create_view_viewname
-    Created 0001_create_view_latest_override.py.
-    $ edit myapp/migrations/0001_create_view_viewname.py
+Creating the views is simple. Just run the ``sync_pgviews`` command.
 
-In the migration file::
-
-    def forwards(self, orm):
-        db.execute('''CREATE OR REPLACE VIEW myapp_viewname AS
-                      SELECT * FROM myapp_table WHERE condition;''')
+Migrations
+==========
 
-    def backwards(self, orm):
-        db.execute('''DROP VIEW myapp_viewname;''')
+Views play well with South migrations; just run ``sync_pgviews`` after
+``migrate`` to ensure any required tables have been created/updated.

django_postgres/view.py

@@ -2,13 +2,14 @@
 
 setup(
     name='django-postgres',
-    version='0.0.1',
+    version='0.0.2',
     description="First-class Postgres feature support for the Django ORM.",
     author='Zachary Voase',
     author_email='z@zacharyvoase.com',
     license='Public Domain',
     packages=find_packages(),
     install_requires=[
         'bitstring',
+        'Django>=1.3',
     ],
 )

doc/views.rst

@@ -113,6 +113,7 @@ def git_name_and_email():
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django_nose',
+    'django_postgres',
     'viewtest',
     'arraytest',
     'bitstringtest',

setup.py

@@ -1,45 +1,51 @@
 from contextlib import closing
 
 from django.contrib import auth
+from django.core.management import call_command
 from django.db import connection
 from django.test import TestCase
 
 import models
 
 
-class ViewTest(TestCase):
+class ViewTestCase(TestCase):
+
+    def setUp(self):
+        call_command('sync_pgviews', *[], **{})
 
     def test_views_have_been_created(self):
         with closing(connection.cursor()) as cur:
             cur.execute('''SELECT COUNT(*) FROM pg_views
                         WHERE viewname LIKE 'viewtest_%';''')
+
             count, = cur.fetchone()
-            assert count == 3
+            self.assertEqual(count, 3)
 
     def test_wildcard_projection(self):
-        foo_user = auth.models.User.objects.create(username='foo',
-                                                   is_superuser=True)
+        foo_user = auth.models.User.objects.create(
+            username='foo', is_superuser=True)
         foo_user.set_password('blah')
         foo_user.save()
 
         foo_superuser = models.Superusers.objects.get(username='foo')
 
-        assert foo_user.id == foo_superuser.id
-        assert foo_user.password == foo_superuser.password
+        self.assertEqual(foo_user.id, foo_superuser.id)
+        self.assertEqual(foo_user.password, foo_superuser.password)
 
     def test_limited_projection(self):
-        foo_user = auth.models.User.objects.create(username='foo',
-                                                   is_superuser=True)
+        foo_user = auth.models.User.objects.create(
+            username='foo', is_superuser=True)
         foo_user.set_password('blah')
         foo_user.save()
 
         foo_simple = models.SimpleUser.objects.get(username='foo')
-        assert foo_simple.username == foo_user.username
-        assert foo_simple.password == foo_user.password
-        assert not hasattr(foo_simple, 'date_joined')
+        self.assertEqual(foo_simple.username, foo_user.username)
+        self.assertEqual(foo_simple.password, foo_user.password)
+        self.assertFalse(hasattr(foo_simple, 'date_joined'))
 
     def test_queryset_based_view(self):
-        foo_user = auth.models.User.objects.create(username='foo',
-                                                   is_staff=True)
+        auth.models.User.objects.create(
+            username='foo', is_staff=True)
 
-        assert models.Staffness.objects.filter(username='foo').exists()
+        self.assertTrue(
+            models.Staffness.objects.filter(username='foo').exists())