MultipleDatabaseSupport: p4.diff

django/db/models/base.py

@@ -38 +38 @@
-                new_class._meta.parents.extend(base._meta.parents)
-
-        model_module = sys.modules[new_class.__module__]
-
+
-        if getattr(new_class._meta, 'app_label', None) is None:
-            # Figure out the app_label by looking one level up.
-            # For 'django.contrib.sites.models', this would be 'sites'.
@@ -149 +149 @@
-        dispatcher.send(signal=signals.pre_save, sender=self.__class__, instance=self)
-
-        non_pks = [f for f in self._meta.fields if not f.primary_key]
-
+self._meta.
-
-        # First, try an UPDATE. If that doesn't update anything, do an INSERT.
-        pk_val = self._get_pk_val()
@@ -362 +362 @@
-        rel = rel_field.rel.to
-        m2m_table = rel_field.m2m_db_table()
-        this_id = self._get_pk_val()
-
+self._meta.
-        cursor.execute("DELETE FROM %s WHERE %s = %%s" % \
-            (backend.quote_name(m2m_table),
-            backend.quote_name(rel_field.m2m_column_name())), [this_id])
@@ -380 +380 @@
-# ORDERING METHODS #########################
-
-def method_set_order(ordered_obj, self, id_list):
+    connection_info = ordered_obj.connection_info
+    connection = info.connection
+    backend = info.backend
+    
-    cursor = connection.cursor()
-    # Example: "UPDATE poll_choices SET _order = %s WHERE poll_id = %s AND id = %s"
-    sql = "UPDATE %s SET %s = %%s WHERE %s = %%s AND %s = %%s" % \
@@ -391 +395 @@
-    transaction.commit_unless_managed()
-
-def method_get_order(ordered_obj, self):
+    connection_info = ordered_obj.connection_info
+    connection = info.connection
+    backend = info.backend
-    cursor = connection.cursor()
-    # Example: "SELECT id FROM poll_choices WHERE poll_id = %s ORDER BY _order"
-    sql = "SELECT %s FROM %s WHERE %s = %%s ORDER BY %s" % \

django/db/models/manager.py

@@ -95 +95 @@
-    def values(self, *args, **kwargs):
-        return self.get_query_set().values(*args, **kwargs)
-
+    #######################
+    # SCHEMA MANIPULATION #
+    #######################
+
+    def install(self, initial_data=False):
+        """Install my model's table, indexes and (if requested) initial data.
+
+        Returns a 3-tuple of the model and lists of statements executed and
+        statements pending. Pending statements are those that could
+        not yet be executed, such as foreign key constraints for
+        tables that don't exist at install time.
+        """
+        creator = self.model._meta.connection_info.get_creation_module()
+        create, pending = creator.get_create_table(self.model)
+        create += creator.get_create_indexes(self.model)
+        if initial_data:
+            create += creator.get_initialdata(self.model)
+
+        executed = []
+        for statement in create:
+            statement.execute()
+        return (self.model, create, pending)
+
+    def load_initial_data(self):
+        """Load initial data for my model into the database."""
+        pass
+
+    def drop(self):
+        """Drop my model's table."""
+        pass
+
+    # Future...
+    
+    def add_column(self, column):
+        """Add a column to my model's table"""
+        pass
+
+    def drop_column(self, column):
+        """Drop a column from my model's table"""
+        pass
+        
+
-class ManagerDescriptor(object):
-    # This class ensures managers aren't accessible via model instances.
-    # For example, Poll.objects works, but poll_obj.objects raises AttributeError.

django/db/models/options.py

@@ -1 +1 @@
-from django.conf import settings
+from django.db import connection_info, connections
-from django.db.models.related import RelatedObject
-from django.db.models.fields.related import ManyToManyRel
-from django.db.models.fields import AutoField, FieldDoesNotExist
@@ -11 +12 @@
-# Calculate the verbose_name by converting from InitialCaps to "lowercase with spaces".
-get_verbose_name = lambda class_name: re.sub('(((?<=[a-z])[A-Z])|([A-Z](?![A-Z]|$)))', ' \\1', class_name).lower().strip()
-
-
+connection', 'db_
-                 'unique_together', 'permissions', 'get_latest_by',
-                 'order_with_respect_to', 'app_label')
-
@@ -20 +21 @@
-        self.fields, self.many_to_many = [], []
-        self.module_name, self.verbose_name = None, None
-        self.verbose_name_plural = None
+        self.db_connection = None
-        self.db_table = ''
-        self.ordering = []
-        self.unique_together =  []
@@ -56 +58 @@
-                raise TypeError, "'class Meta' got invalid attribute(s): %s" % ','.join(meta_attrs.keys())
-        else:
-            self.verbose_name_plural = self.verbose_name + 's'
+        # 
-        del self.meta
-
-    def _prepare(self, model):
@@ -88 +91 @@
-    def __repr__(self):
-        return '<Options for %s>' % self.object_name
-
+    def get_connection_info(self):
+        if self.db_connection:
+            return connections[self.db_connection]
+        return connection_info
+    connection_info = property(get_connection_info)
+            
+    def get_connection(self):
+        """Get the database connection for this object's model"""
+        return self.get_connection_info().connection
+    connection = property(get_connection)
+    
-    def get_field(self, name, many_to_many=True):
-        "Returns the requested field by name. Raises FieldDoesNotExist on error."
-        to_search = many_to_many and (self.fields + self.many_to_many) or self.fields

django/db/models/loading.py

@@ -8 +8 @@
-_app_list = None # Cache of installed apps.
-_app_models = {} # Dictionary of models against app label
-                 # Each value is a dictionary of model name: model class
-
+
+
+
-def get_apps():
-    "Returns a list of all installed modules that contain models."
-    global _app_list
@@ -35 +37 @@
-            return __import__(app_name, '', '', ['models']).models
-    raise ImproperlyConfigured, "App with label %s could not be found" % app_label
-
-
+, creation_order=False
-    """
-    Given a module containing models, returns a list of the models. Otherwise
-
+
+
+
-    """
-    app_list = get_apps() # Run get_apps() to populate the _app_list cache. Slightly hackish.
-    if app_mod:
-
+
+
+
+
+
+
-    else:
-        model_list = []
-        for app_mod in app_list:
@@ -75 +84 @@
-        model_name = model._meta.object_name.lower()
-        model_dict = _app_models.setdefault(app_label, {})
-        model_dict[model_name] = model
+        model_list = _app_model_order.setdefault(app_label, [])
+        model_list.append(model_name)

django/db/models/query.py

@@ -1 @@
-
+connections, 
-from django.db.models.fields import DateField, FieldDoesNotExist
-from django.db.models import signals
-from django.dispatch import dispatcher
@@ -158 +158 @@
-        # undefined, so we convert it to a list of tuples.
-        extra_select = self._select.items()
-
-
+self.model._meta.
-        select, sql, params = self._get_sql_clause()
-        cursor.execute("SELECT " + (self._distinct and "DISTINCT " or "") + ",".join(select) + sql, params)
-        fill_cache = self._select_related
@@ -178 +178 @@
-
-    def count(self):
-        "Performs a SELECT COUNT() and returns the number of records as an integer."
+
+        info = self.model._meta.connection_info
+        backend = info.backend
+        connection = info.connection
+        
-        counter = self._clone()
-        counter._order_by = ()
-        counter._offset = None
@@ -505 +510 @@
-            columns = [f.column for f in self.model._meta.fields]
-            field_names = [f.attname for f in self.model._meta.fields]
-
+        info = self.model._meta.connection_info
+        backend = info.backend
+        connection = info.connection
-        cursor = connection.cursor()
-        select, sql, params = self._get_sql_clause()
-        select = ['%s.%s' % (backend.quote_name(self.model._meta.db_table), backend.quote_name(c)) for c in columns]
@@ -524 +532 @@
-class DateQuerySet(QuerySet):
-    def iterator(self):
-        from django.db.backends.util import typecast_timestamp
+
+        info = self.model._meta.connection_info
+        backend = info.backend
+        connection = info.connection
+        
-        self._order_by = () # Clear this because it'll mess things up otherwise.
-        if self._field.null:
-            self._where.append('%s.%s IS NOT NULL' % \
@@ -616 +629 @@
-        where2 = ['(NOT (%s))' % " AND ".join(where)]
-        return tables, joins, where2, params
-
-
+
+
+
-    if table_prefix.endswith('.'):
-        table_prefix = backend.quote_name(table_prefix[:-1])+'.'
-    field_name = backend.quote_name(field_name)
@@ -745 +760 @@
-    intermediate_table = None
-    join_required = False
-
+    info = current_opts.connection_info
+    backend = info.backend
+    connection = info.connection
+
-    name = path.pop(0)
-    # Has the primary key been requested? If so, expand it out
-    # to be the name of the current class' primary key
@@ -872 +891 @@
-        else:
-            column = field.column
-
-
+urrent_opts, c
-        params.extend(field.get_db_prep_lookup(clause, value))
-
-    return tables, joins, where, params
@@ -882 +901 @@
-    ordered_classes = seen_objs.keys()
-    ordered_classes.reverse()
-
-    cursor = connection.cursor()
-
-    for cls in ordered_classes:
+
+        info = cls._meta.connection_info
+        backend = info.backend
+        connection = info.connection
+        cursor = connection.cursor()
+        
-        seen_objs[cls] = seen_objs[cls].items()
-        seen_objs[cls].sort()
-
@@ -919 +943 @@
-
-    # Now delete the actual data
-    for cls in ordered_classes:
+
+        info = cls._meta.connection_info
+        backend = info.backend
+        connection = info.connection
+        cursor = connection.cursor()
+
-        seen_objs[cls].reverse()
-        pk_list = [pk for pk,instance in seen_objs[cls]]
-        for offset in range(0, len(pk_list), GET_ITERATOR_CHUNK_SIZE):

django/db/__init__.py

@@ -1 @@
-
+, UserSettingsHolder
-from django.core import signals
+from django.core.exceptions import ImproperlyConfigured
-from django.dispatch import dispatcher
-
-__all__ = ('backend', 'connection', 'DatabaseError')
@@ -7 +8 @@
-if not settings.DATABASE_ENGINE:
-    settings.DATABASE_ENGINE = 'dummy'
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-
-
+
+
+
+
+
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-# Register an event that closes the database connection
-# when a Django request is finished.
-dispatcher.connect(connection.close, signal=signals.request_finished)
-
+    get_introspection_module = lambda: __import__('django.db.backends.%s.introspection' % settings.DATABASE_ENGINE, '', '', [''])
+    get_creation_module = lambda: __import__('django.db.backends.%s.creation' % settings.DATABASE_ENGINE, '', '', [''])
+    runshell = lambda: __import__('django.db.backends.%s.client' % settings.DATABASE_ENGINE, '', '', ['']).runshell()
+
+    connection = backend.DatabaseWrapper(settings)
+    DatabaseError = backend.DatabaseError
+
+    return ConnectionInfo(connection, DatabaseError, backend, 
+                          get_introspection_module, get_creation_module,
+                          runshell)
+
+connection_info = connect(settings)
+
+# backwards compatibility
+(connection, DatabaseError, backend, get_introspection_module, 
+ get_creation_module, runshell) = (connection_info.connection,
+                                   connection_info.DatabaseError,
+                                   connection_info.backend,
+                                   connection_info.get_introspection_module, 
+                                   connection_info.get_creation_module,
+                                   connection_info.runshell)
+
+
+class LazyConnectionManager(object):
+    """Manages named connections lazily, instantiating them as
+    they are requested.
+    """
+
+    def __init__(self):
+        self._connections = {}
+
+    def __getitem__(self, k):
+        try:
+            return self._connections[k]
+        except KeyError:
+            try:
+                self.connect(k)
+                return self._connections[k]
+            except KeyError:
+                raise ImproperlyConfigured, \
+                      "No database connection '%s' has been configured" % k
+            
+    def connect(self, name):
+        from django.conf import settings
+        try:
+            database = settings.DATABASES[name]
+            try:
+                database.DATABASE_ENGINE
+            except AttributeError:
+                # assume its a dict and convert to settings instance
+                holder = UserSettingsHolder(settings)
+                for k, v in database.items():
+                    setattr(holder, k, v)
+                    database = holder
+                settings.DATABASES[name] = database
+            self._connections[name] = connect(database)
+        except AttributeError:
+            # no named connections to set up
+            pass
+
+connections = LazyConnectionManager()
+
-# Register an event that resets connection.queries
-# when a Django request is started.
-
+connection=connection
-    connection.queries = []
-dispatcher.connect(reset_queries, signal=signals.request_started)
-
@@ -46 +125 @@
-    from django.db import transaction
-    transaction.rollback_unless_managed()
-dispatcher.connect(_rollback_on_exception, signal=signals.got_request_exception)
+
+# Register an event that closes the database connection
+# when a Django request is finished.
+dispatcher.connect(connection.close, signal=signals.request_finished)
+

django/db/backends/postgresql/base.py

@@ -21 +21 @@
-    from django.utils._threading_local import local
-
-class DatabaseWrapper(local):
-
+
+
-        self.connection = None
-        self.queries = []
-
-    def cursor(self):
-from django.conf import 
+settings = self.
-        if self.connection is None:
-            if settings.DATABASE_NAME == '':
-                from django.core.exceptions import ImproperlyConfigured

django/db/backends/postgresql/creation.py

@@ +1 @@
+from django.db.backends.ansi.creation import SchemaBuilder
+
-# This dictionary maps Field objects to their associated PostgreSQL column
-# types, as strings. Column-type strings can contain format strings; they'll
-# be interpolated against the values of Field.__dict__ before being output.
@@ -28 +30 @@
-    'URLField':          'varchar(200)',
-    'USStateField':      'varchar(2)',
-}
+
+_builder = SchemaBuilder()
+get_create_table = _builder.get_create_table
+get_create_indexes = _builder.get_create_indexes
+get_initialdata = _builder.get_initialdata

django/db/backends/sqlite3/base.py

@@ -34 +34 @@
-    from django.utils._threading_local import local
-
-class DatabaseWrapper(local):
-
+
+
-        self.connection = None
-        self.queries = []
-
-    def cursor(self):
-from django.conf import 
+settings = self.
-        if self.connection is None:
-            self.connection = Database.connect(settings.DATABASE_NAME,
-                detect_types=Database.PARSE_DECLTYPES | Database.PARSE_COLNAMES)

django/db/backends/sqlite3/creation.py

@@ +1 @@
+from django.db.backends.ansi.creation import SchemaBuilder
+
-# SQLite doesn't actually support most of these types, but it "does the right
-# thing" given more verbose field definitions, so leave them as is so that
-# schema inspection is more useful.
@@ -27 +29 @@
-    'URLField':                     'varchar(200)',
-    'USStateField':                 'varchar(2)',
-}
+
+_builder = SchemaBuilder()
+get_create_table = _builder.get_create_table
+get_create_indexes = _builder.get_create_indexes
+get_initialdata = _builder.get_initialdata

django/db/backends/ansi/creation.py

@@ +1 @@
+"""ANSISQL schema manipulation functions and classes
+"""
+from django.db import models
+
+# FIXME correct handling of styles,
+# allow style object to be passed in
+class dummy:
+    def __getattr__(self, attr):
+        return lambda x: x
+
+class BoundStatement(object):    
+    def __init__(self, sql, connection):
+        self.sql = sql
+        self.connection = connection
+
+    def execute(self):
+        cursor = self.connection.cursor()
+        cursor.execute(self.sql)
+
+    def __repr__(self):
+        return "BoundStatement(%r)" % self.sql
+
+    def __str__(self):
+        return self.sql
+
+    def __eq__(self, other):
+        return self.sql == other.sql and self.connection == other.connection
+
+class SchemaBuilder(object):
+    def __init__(self):
+        self.models_already_seen = []
+        
+    def get_create_table(self, model, style=dummy()):
+        if model in self.models_already_seen:
+            return (None, None, None)
+        self.models_already_seen.append(model)
+        
+        opts = model._meta
+        info = opts.connection_info
+        backend = info.backend
+        quote_name = backend.quote_name
+        data_types = info.get_creation_module().DATA_TYPES
+        table_output = []
+        pending_references = {} 
+        pending = [] # actual pending statements to execute
+        for f in opts.fields:
+            if isinstance(f, models.ForeignKey):
+                rel_field = f.rel.get_related_field()
+                data_type = self.get_rel_data_type(rel_field)
+            else:
+                rel_field = f
+                data_type = f.get_internal_type()
+            col_type = data_types[data_type]
+            if col_type is not None:
+                # Make the definition (e.g. 'foo VARCHAR(30)') for this field.
+                field_output = [style.SQL_FIELD(quote_name(f.column)),
+                    style.SQL_COLTYPE(col_type % rel_field.__dict__)]
+                field_output.append(style.SQL_KEYWORD('%sNULL' % (not f.null and 'NOT ' or '')))
+                if f.unique:
+                    field_output.append(style.SQL_KEYWORD('UNIQUE'))
+                if f.primary_key:
+                    field_output.append(style.SQL_KEYWORD('PRIMARY KEY'))
+                if f.rel:
+                    if f.rel.to in self.models_already_seen:
+                        field_output.append(style.SQL_KEYWORD('REFERENCES') + ' ' + \
+                            style.SQL_TABLE(quote_name(f.rel.to._meta.db_table)) + ' (' + \
+                            style.SQL_FIELD(quote_name(f.rel.to._meta.get_field(f.rel.field_name).column)) + ')'
+                        )
+                    else:
+                        # We haven't yet created the table to which this field
+                        # is related, so save it for later.
+                        pr = pending_references.setdefault(f.rel.to, []).append(f)
+                table_output.append(' '.join(field_output))
+        if opts.order_with_respect_to:
+            table_output.append(style.SQL_FIELD(quote_name('_order')) + ' ' + \
+                style.SQL_COLTYPE(data_types['IntegerField']) + ' ' + \
+                style.SQL_KEYWORD('NULL'))
+        for field_constraints in opts.unique_together:
+            table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \
+                ", ".join([quote_name(style.SQL_FIELD(opts.get_field(f).column)) for f in field_constraints]))
+
+        full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(quote_name(opts.db_table)) + ' (']
+        for i, line in enumerate(table_output): # Combine and add commas.
+            full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or ''))
+        full_statement.append(');')
+
+        create = [BoundStatement('\n'.join(full_statement), opts.connection)]
+
+        if (pending_references and
+            backend.supports_constraints):
+            for rel_class, cols in pending_references.items():
+                for f in cols:
+                    rel_opts = rel_class._meta
+                    r_table = rel_opts.db_table
+                    r_col = f.column
+                    table = opts.db_table
+                    col = opts.get_field(f.rel.field_name).column
+                    sql = style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s);' % \
+                        (quote_name(table),
+                        quote_name('%s_referencing_%s_%s' % (r_col, r_table, col)),
+                        quote_name(r_col), quote_name(r_table), quote_name(col))
+                    pending.append(BoundStatement(sql, opts.connection))
+        return (create, pending)    
+
+    def get_create_indexes(self, model, style=dummy()):
+        return [] # FIXME
+
+    def get_initialdata(self, model, style=dummy()):
+        return [] # FIXME
+
+    def get_rel_data_type(self, f):
+        return (f.get_internal_type() in ('AutoField', 'PositiveIntegerField',
+                                          'PositiveSmallIntegerField')) \
+                                          and 'IntegerField' \
+                                          or f.get_internal_type()

tests/modeltests/multiple_databases/models.py

@@ +1 @@
+"""
+N. Using multiple database connections
+
+Django normally uses only a single database connection. However, support is
+available for connecting to any number of different, named databases on a
+per-model-class level.
+
+Please note that this test uses hard-coded databases, and will fail
+unless sqlite3 is install and /tmp is writeable. It also will
+currently fail unless the two temp databases are removed by hand
+between runs. It also side-effects the settings as set in the
+DJANGO_SETTINGS_MODULE. All of these are undesirable, and mean that
+this test is almost certainly going to have to move to othertests.
+
+It would be really nice if the testrunner supported setup and teardown.
+
+"""
+
+# models can define which connections they will use
+from django.db import models
+
+class Artist(models.Model):
+    name = models.CharField(maxlength=100)
+    alive = models.BooleanField(default=True)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'a'
+        
+class Widget(models.Model):
+    code = models.CharField(maxlength=10, unique=True)
+    weight = models.IntegerField()
+
+    def __str__(self):
+        return self.code
+    
+    class Meta:
+        db_connection = 'b'
+
+
+# but they don't have to
+class Vehicle(models.Model):
+    make = models.CharField(maxlength=20)
+    model = models.CharField(maxlength=20)
+    year = models.IntegerField()
+
+    def __str__(self):
+        return "%d %s %s" % (self.year, self.make, self.model)
+
+API_TESTS = """
+
+# Connections are established lazily, when requested by name.
+
+>>> from django.conf import settings
+>>> settings.DATABASES = { 
+...     'a': { 'DATABASE_ENGINE': 'sqlite3',
+...            'DATABASE_NAME': '/tmp/dba.db'
+...     },
+...     'b': { 'DATABASE_ENGINE': 'sqlite3',
+...            'DATABASE_NAME': '/tmp/dbb.db'
+...     }}
+>>> from django.db import connections
+
+# connections[database] holds a tuple of connection, DatabaseError, backend, 
+# get_introspection_module, get_creation_module, and runshell
+
+>>> connections['a']
+Connection: <django.db.backends.sqlite3.base.DatabaseWrapper object at ...> (ENGINE=sqlite3 NAME=/tmp/dba.db)
+>>> connections['b']
+Connection: <django.db.backends.sqlite3.base.DatabaseWrapper object at ...> (ENGINE=sqlite3 NAME=/tmp/dbb.db)
+
+# Invalid connection names raise ImproperlyConfigured
+
+>>> connections['bad']
+Traceback (most recent call last):
+    ...
+ImproperlyConfigured: No database connection 'bad' has been configured
+
+# For the time being, we have to install the models by hand
+
+>>> from django.core import management
+>>> artist_sql = ''.join(management._get_sql_model_create(Artist)[0])
+>>> cursor = Artist._meta.connection.cursor()
+>>> cursor.execute(artist_sql)
+>>> widget_sql = ''.join(management._get_sql_model_create(Widget)[0])
+>>> cursor = Widget._meta.connection.cursor()
+>>> cursor.execute(widget_sql)
+
+# Then we can play with them
+
+>>> a = Artist(name="Paul Klee", alive=False)
+>>> a.save()
+>>> a._meta.connection.settings.DATABASE_NAME
+'/tmp/dba.db'
+>>> w = Widget(code='100x2r', weight=1000)
+>>> w.save()
+>>> w._meta.connection.settings.DATABASE_NAME
+'/tmp/dbb.db'
+>>> v = Vehicle(make='Chevy', model='Camaro', year='1966')
+>>> v.save()
+>>> v._meta.connection.settings.DATABASE_NAME
+':memory:'
+
+# Managers use their models' connections
+
+>>> artists = Artist.objects.all()
+>>> list(artists)
+[<Artist: Paul Klee>]
+>>> artists[0]._meta.connection.settings.DATABASE_NAME
+'/tmp/dba.db'
+>>> widgets = Widget.objects.all()
+>>> list(widgets)
+[<Widget: 100x2r>]
+>>> widgets[0]._meta.connection.settings.DATABASE_NAME
+'/tmp/dbb.db'
+>>> vehicles = Vehicle.objects.all()
+>>> list(vehicles)
+[<Vehicle: 1966 Chevy Camaro>]
+>>> vehicles[0]._meta.connection.settings.DATABASE_NAME
+':memory:'
+
+# Managed transactions may be restricted to certain databases
+
+# But by default they cover all databases
+
+
+"""

tests/modeltests/manager_schema_manipulation/models.py

@@ +1 @@
+"""
+N. Schema manipulations
+
+Django uses a model's manager to perform schema manipulations such as
+creating or dropping the model's table.
+
+Please note that your settings file must define DATABASES with names
+'a' and 'b' for this test.
+"""
+
+from django.db import models
+
+# default connection
+class DA(models.Model):
+    name = models.CharField(maxlength=20)
+
+    def __str__(self):
+        return self.name
+    
+# connection a
+class AA(models.Model):
+    name = models.CharField(maxlength=20)
+    # This creates a cycle in the dependency graph
+    c = models.ForeignKey('AC', null=True)
+    
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'a'
+
+class AB(models.Model):
+    name = models.CharField(maxlength=20)
+    a = models.ForeignKey(AA)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'a'
+
+class AC(models.Model):
+    name = models.CharField(maxlength=20)
+    b = models.ForeignKey(AB)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'a'
+
+# connection b
+class BA(models.Model):
+    name = models.CharField(maxlength=20)
+
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'b'
+
+class BB(models.Model):
+    name = models.CharField(maxlength=20)
+    a = models.ForeignKey(BA)
+    
+    def __str__(self):
+        return self.name
+
+    class Meta:
+        db_connection = 'b'
+
+
+
+API_TESTS = """
+
+# models can use the default connection or a named connection
+
+# FIXME: DA is already installed
+# models can be installed individually
+
+>>> BA._default_manager.install()
+(<class 'modeltests.manager_schema_manipulation.models.BA'>, [BoundStatement('CREATE TABLE "manager_schema_manipulation_ba" (...);')], [])
+>>> BB._default_manager.install()
+(<class 'modeltests.manager_schema_manipulation.models.BB'>, [BoundStatement('CREATE TABLE "manager_schema_manipulation_bb" (...);')], [])
+>>> list(BA.objects.all())
+[]
+>>> BA(name="something").save()
+>>> BA.objects.all()
+[<BA: something>]
+
+# models with un-installable dependencies will return a list of
+# pending statements; these are bound to the model's connection and should
+# be executed after all other models have been created
+
+>>> result = AA._default_manager.install()
+>>> result
+(<class 'modeltests.manager_schema_manipulation.models.AA'>, [BoundStatement('CREATE TABLE "manager_schema_manipulation_aa" (...);')], [BoundStatement('ALTER TABLE "manager_schema_manipulation_aa" ADD CONSTRAINT "c_id_referencing_manager_schema_manipulation_ac_id" FOREIGN KEY ("c_id") REFERENCES "manager_schema_manipulation_ac" ("id");')])
+
+
+"""